@akshar5/cohall 0.9.0 → 0.10.0

package/bin/cohall.js

@@ -17,9 +17,9 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // packages/protocol/src/index.ts
 import { Effect, Schema } from "effect";
-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$/, {
+var version = "0.10.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) => {
+})).pipe(Schema.brand(name)), BotId, Bot, DeviceId, ThreadId, MessageId, TaskId, TaskRequestId, TaskRunId, ClarificationId, AuthSessionId, OperationId, Timestamp, TaskDeadline, taskDeadlineError = "Task deadline exceeded", taskDeadlinePassed = (task, time = Date.now()) => task.expiresAt !== undefined && Date.parse(task.expiresAt) <= time, Platform, Provider, DeviceStatus, TaskStatus, OperationStatus, TaskTraceEventKind, MessageRole, ConnectionRole, AuthSession, CreatePairingInput, PairingCredential, ExchangePairingInput, SessionCredential, PairingResult, Capability, Workspace, Device, maxDevicePageDevices = 16, maxDevicePageResponseBytes, DevicePage, minimumDeviceOperationVersion = "0.5.0", parsedVersion = (value) => {
   const match = /^v?(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.exec(value);
   if (match === null) {
     return;
@@ -56,7 +56,7 @@ var version = "0.9.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";
-}, 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) => ({
+}, TaskProgressInput, TaskProgress, maxClarificationBytes = 4096, maxTaskClarifications = 10, clarificationText, RequestTaskInput, AnswerTaskInput, TaskClarification, clarifications, validClarificationState = (task) => task.status !== "needs_input" || task.clarifications?.at(-1) !== undefined && task.clarifications.at(-1)?.answer === undefined ? undefined : "A task awaiting input must have an unanswered question", 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, decodeRequestTaskInput, decodeAnswerTaskInput, decodeExchangePairingInput, decodeCreateTaskInput = (input) => Schema.decodeUnknownEffect(CreateTaskInput)(input).pipe(Effect.map((task) => ({
   ...task,
   provider: task.provider ?? (task.botId === undefined ? "codex" : "grok-bot")
 }))), decodeCreateUpgradeOperationsInput, decodeDevice, decodeSocketEvent;
@@ -74,9 +74,16 @@ var init_src = __esm(() => {
   ThreadId = uuid("ThreadId");
   MessageId = uuid("MessageId");
   TaskId = uuid("TaskId");
+  TaskRequestId = uuid("TaskRequestId");
+  TaskRunId = uuid("TaskRunId");
+  ClarificationId = uuid("ClarificationId");
   AuthSessionId = uuid("AuthSessionId");
   OperationId = uuid("OperationId");
   Timestamp = isoTimestamp("Timestamp");
+  TaskDeadline = Timestamp.check(Schema.makeFilter((value) => {
+    const time = Date.parse(value);
+    return Number.isFinite(time) && new Date(time).toISOString().slice(0, 19) === value.slice(0, 19) ? undefined : "Expected a valid ISO-8601 UTC deadline";
+  }));
   Platform = Schema.Literals(["darwin", "linux", "windows", "unknown"]);
   Provider = Schema.Literals(["codex", "claude-code", "opencode", "grok-bot"]);
   DeviceStatus = Schema.Literals(["online", "busy", "offline"]);
@@ -84,6 +91,7 @@ var init_src = __esm(() => {
     "queued",
     "assigned",
     "running",
+    "needs_input",
     "cancelling",
     "completed",
     "failed",
@@ -96,7 +104,12 @@ var init_src = __esm(() => {
     "completed",
     "failed"
   ]);
-  TaskTraceEventKind = Schema.Literals([...TaskStatus.literals, "requeued"]);
+  TaskTraceEventKind = Schema.Literals([
+    ...TaskStatus.literals,
+    "requeued",
+    "input_requested",
+    "input_answered"
+  ]);
   MessageRole = Schema.Literals(["human", "agent", "system"]);
   ConnectionRole = Schema.Literals(["client", "device"]);
   AuthSession = Schema.Struct({
@@ -155,6 +168,19 @@ var init_src = __esm(() => {
       oldestQueuedAt: Schema.optionalKey(Timestamp)
     }))
   });
+  maxDevicePageResponseBytes = 3 * 1024 * 1024;
+  DevicePage = Schema.Struct({
+    devices: boundedArray(Device, maxDevicePageDevices),
+    nextCursor: Schema.optionalKey(DeviceId)
+  }).check(Schema.makeFilter((page) => {
+    let previous;
+    for (const device of page.devices) {
+      if (previous !== undefined && device.id <= previous)
+        return "Device pages must be ordered by ID";
+      previous = device.id;
+    }
+    return page.nextCursor === undefined || page.nextCursor === previous ? undefined : "The next cursor must be the last device ID";
+  }));
   Thread = Schema.Struct({
     id: ThreadId,
     title: bounded(256),
@@ -188,8 +214,22 @@ var init_src = __esm(() => {
     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 });
+  clarificationText = bounded(maxClarificationBytes).check(Schema.makeFilter((value) => value.trim().length > 0 && new TextEncoder().encode(value).byteLength <= maxClarificationBytes ? undefined : `Expected nonblank text of at most ${maxClarificationBytes} UTF-8 bytes`)).pipe(Schema.brand("ClarificationText"));
+  RequestTaskInput = Schema.Struct({ runId: TaskRunId, question: clarificationText });
+  AnswerTaskInput = Schema.Struct({
+    requestId: ClarificationId,
+    answer: clarificationText
+  });
+  TaskClarification = Schema.Struct({
+    id: ClarificationId,
+    question: RequestTaskInput.fields.question,
+    at: Timestamp,
+    answer: Schema.optionalKey(Schema.Struct({ text: AnswerTaskInput.fields.answer, at: Timestamp }))
+  });
+  clarifications = boundedArray(TaskClarification, maxTaskClarifications);
   Task = Schema.Struct({
     id: TaskId,
+    runId: Schema.optionalKey(TaskRunId),
     threadId: ThreadId,
     prompt: bounded(131072),
     context: Schema.optionalKey(optionalText(131072)),
@@ -205,23 +245,26 @@ var init_src = __esm(() => {
     inputAttachmentNames: Schema.optionalKey(boundedArray(AttachmentName, maxTaskAttachments)),
     error: Schema.optionalKey(optionalText(16384)),
     progress: Schema.optionalKey(TaskProgress),
+    clarifications: Schema.optionalKey(clarifications),
     createdAt: Timestamp,
     updatedAt: Timestamp,
     startedAt: Schema.optionalKey(Timestamp),
-    completedAt: Schema.optionalKey(Timestamp)
-  }).check(Schema.makeFilter(validBotTarget));
+    completedAt: Schema.optionalKey(Timestamp),
+    expiresAt: Schema.optionalKey(TaskDeadline)
+  }).check(Schema.makeFilter(validBotTarget), Schema.makeFilter(validClarificationState));
   TaskInboxItem = Schema.Struct({
     id: TaskId,
     threadId: ThreadId,
     targetDeviceId: DeviceId,
     provider: Provider,
     botId: Schema.optionalKey(BotId),
-    status: Schema.Literals(["completed", "failed", "cancelled"]),
+    status: Schema.Literals(["needs_input", "completed", "failed", "cancelled"]),
     promptPreview: optionalText(320),
     resultPreview: Schema.optionalKey(optionalText(1024)),
     errorPreview: Schema.optionalKey(optionalText(1024)),
-    completedAt: Timestamp
-  });
+    completedAt: Schema.optionalKey(Timestamp),
+    inputRequest: Schema.optionalKey(TaskClarification)
+  }).check(Schema.makeFilter((item) => item.status === "needs_input" ? item.inputRequest !== undefined && item.inputRequest.answer === undefined && item.completedAt === undefined ? undefined : "An input request must have an unanswered question and no completion time" : item.completedAt !== undefined && item.inputRequest === undefined ? undefined : "A completion must have a completion time and no input request"));
   TaskInbox = Schema.Struct({
     items: boundedArray(TaskInboxItem, 20),
     hasMore: Schema.Boolean
@@ -250,6 +293,7 @@ var init_src = __esm(() => {
     queued: count,
     assigned: count,
     running: count,
+    needs_input: Schema.optionalKey(count),
     cancelling: count,
     completed: count,
     failed: count,
@@ -291,11 +335,13 @@ var init_src = __esm(() => {
     updatedAt: Timestamp,
     startedAt: Schema.optionalKey(Timestamp),
     completedAt: Schema.optionalKey(Timestamp),
+    expiresAt: Schema.optionalKey(TaskDeadline),
     events: boundedArray(TaskTraceEvent, 100),
     truncated: Schema.Boolean,
     error: Schema.optionalKey(optionalText(16384)),
-    progress: Schema.optionalKey(TaskProgress)
-  }).check(Schema.makeFilter(validBotTarget));
+    progress: Schema.optionalKey(TaskProgress),
+    clarifications: Schema.optionalKey(clarifications)
+  }).check(Schema.makeFilter(validBotTarget), Schema.makeFilter(validClarificationState));
   ThreadContext = Schema.Struct({
     thread: Thread,
     messages: boundedArray(Message, 20),
@@ -303,6 +349,7 @@ var init_src = __esm(() => {
     truncated: Schema.Boolean
   });
   CreateTaskInput = Schema.Struct({
+    requestId: Schema.optionalKey(TaskRequestId),
     threadId: Schema.optionalKey(ThreadId),
     title: Schema.optionalKey(bounded(256)),
     prompt: bounded(131072),
@@ -311,6 +358,7 @@ var init_src = __esm(() => {
     botId: Schema.optionalKey(BotId),
     targetDeviceId: Schema.optionalKey(DeviceId),
     parentTaskId: Schema.optionalKey(TaskId),
+    expiresAt: Schema.optionalKey(TaskDeadline),
     workspace: Schema.optionalKey(bounded(4096)),
     attachments: Schema.optionalKey(attachments)
   }).check(Schema.makeFilter(validBotTarget));
@@ -319,7 +367,9 @@ var init_src = __esm(() => {
     Connected: {
       serverVersion: bounded(32),
       connectedAt: Timestamp,
-      taskAttachments: Schema.optionalKey(Schema.Boolean)
+      taskAttachments: Schema.optionalKey(Schema.Boolean),
+      taskClarification: Schema.optionalKey(Schema.Boolean),
+      taskDeadlines: Schema.optionalKey(Schema.Boolean)
     },
     DeviceHello: { device: Device },
     DeviceHeartbeat: {
@@ -328,17 +378,22 @@ var init_src = __esm(() => {
       bots: Schema.optionalKey(boundedArray(Bot, 256))
     },
     TaskAssigned: { task: Task },
-    TaskAccepted: { taskId: TaskId },
+    TaskAccepted: { taskId: TaskId, runId: Schema.optionalKey(TaskRunId) },
     TaskFinished: {
       taskId: TaskId,
+      runId: Schema.optionalKey(TaskRunId),
       result: optionalText(131072),
       attachments: Schema.optionalKey(attachments),
       providerSessionId: Schema.optionalKey(bounded(4096))
     },
-    TaskFailed: { taskId: TaskId, error: bounded(16384) },
-    TaskCancelled: { taskId: TaskId },
-    TaskSettled: { taskId: TaskId },
-    CancelTask: { taskId: TaskId },
+    TaskInputRequested: {
+      taskId: TaskId,
+      ...RequestTaskInput.fields
+    },
+    TaskFailed: { taskId: TaskId, runId: Schema.optionalKey(TaskRunId), error: bounded(16384) },
+    TaskCancelled: { taskId: TaskId, runId: Schema.optionalKey(TaskRunId) },
+    TaskSettled: { taskId: TaskId, runId: Schema.optionalKey(TaskRunId) },
+    CancelTask: { taskId: TaskId, runId: Schema.optionalKey(TaskRunId) },
     OperationAssigned: { operation: DeviceOperation },
     OperationAccepted: { operationId: OperationId },
     OperationFinished: { operationId: OperationId, result: optionalText(16384) },
@@ -356,6 +411,8 @@ var init_src = __esm(() => {
   ]);
   decodeCreatePairingInput = Schema.decodeUnknownEffect(CreatePairingInput);
   decodeTaskProgressInput = Schema.decodeUnknownEffect(TaskProgressInput);
+  decodeRequestTaskInput = Schema.decodeUnknownEffect(RequestTaskInput);
+  decodeAnswerTaskInput = Schema.decodeUnknownEffect(AnswerTaskInput);
   decodeExchangePairingInput = Schema.decodeUnknownEffect(ExchangePairingInput);
   decodeCreateUpgradeOperationsInput = Schema.decodeUnknownEffect(CreateUpgradeOperationsInput);
   decodeDevice = Schema.decodeUnknownEffect(Device);
@@ -366,7 +423,7 @@ var init_src = __esm(() => {
 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 join9, resolve as resolve4 } from "node:path";
+import { join as join9, resolve as resolve5 } from "node:path";
 var RelayConfiguration, defaultDataDirectory = () => {
   if (platform5() === "win32") {
     return join9(process.env.LOCALAPPDATA ?? join9(homedir5(), "AppData", "Local"), "Cohall");
@@ -414,7 +471,7 @@ var init_config = __esm(() => {
       if (!isLoopback2(host) && !allowRemote) {
         throw new Error("Remote relay binding is disabled. Use a private network or TLS reverse proxy, then set COHALL_RELAY_ALLOW_REMOTE=true.");
       }
-      const dataDirectory = resolve4(process.env.COHALL_DATA_DIR ?? defaultDataDirectory());
+      const dataDirectory = resolve5(process.env.COHALL_DATA_DIR ?? defaultDataDirectory());
       await mkdir8(dataDirectory, { recursive: true, mode: 448 });
       if (platform5() !== "win32") {
         await chmod7(dataDirectory, 448);
@@ -607,14 +664,17 @@ var exports_store = {};
 __export(exports_store, {
   layerFromDatabase: () => layerFromDatabase,
   layer: () => layer2,
+  TaskRequestError: () => TaskRequestError,
   TaskProgressError: () => TaskProgressError,
+  TaskInputError: () => TaskInputError,
+  TaskDeadlineError: () => TaskDeadlineError,
   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, TaskProgressError, Service2, operationError = (operation) => (cause) => new PersistenceError({
+var PersistenceError, TaskProgressError, TaskInputError, TaskDeadlineError, TaskRequestError, 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, {
@@ -657,6 +717,8 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
   catch: operationError("RelayStore.taskAttachments")
 }).pipe(Effect14.flatMap((attachments2) => decode2("RelayStore.decodeTask", Task, {
   id: row.id,
+  ...row.run_id === null ? {} : { runId: row.run_id },
+  ...row.clarifications_json === null ? {} : { clarifications: JSON.parse(row.clarifications_json) },
   threadId: row.thread_id,
   prompt: row.prompt,
   provider: row.provider,
@@ -665,6 +727,7 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
   targetDeviceId: row.target_device_id,
   createdAt: row.created_at,
   updatedAt: row.updated_at,
+  ...row.expires_at === null ? {} : { expiresAt: row.expires_at },
   ...row.context === null ? {} : { context: row.context },
   ...row.source_device_id === null ? {} : { sourceDeviceId: row.source_device_id },
   ...row.parent_task_id === null ? {} : { parentTaskId: row.parent_task_id },
@@ -684,7 +747,8 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
   ...row.bot_id === null ? {} : { botId: row.bot_id },
   status: row.status,
   promptPreview: row.prompt_preview,
-  completedAt: row.completed_at,
+  ...row.completed_at === null ? {} : { completedAt: row.completed_at },
+  ...row.input_request_json === null ? {} : { inputRequest: JSON.parse(row.input_request_json) },
   ...row.result_preview === null ? {} : { resultPreview: row.result_preview },
   ...row.error_preview === null ? {} : { errorPreview: row.error_preview }
 }), operationFromRow = (row) => decode2("RelayStore.decodeOperation", DeviceOperation, {
@@ -703,6 +767,7 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
   queued: 0,
   assigned: 0,
   running: 0,
+  needs_input: 0,
   cancelling: 0,
   completed: 0,
   failed: 0,
@@ -774,7 +839,52 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     events.push(TaskTraceEvent.make({ kind: task.status, at: task.completedAt, detail }));
   }
   return events;
-}, makeService = (db, retainedTerminalTasks = 1000) => {
+}, interruptedTaskStatus = `CASE
+  WHEN json_array_length(clarifications_json) > 0
+    AND json_extract(clarifications_json, '$[#-1].answer') IS NULL THEN 'needs_input'
+  ELSE 'queued' END`, makeService = (db, retainedTerminalTasks = 1000) => {
+  const requestHash = (input) => {
+    const { requestId: _requestId, attachments: attachments2, ...fields } = input;
+    const normalized = {
+      ...fields,
+      provider: input.provider ?? (input.botId === undefined ? "codex" : "grok-bot"),
+      ...attachments2 === undefined || attachments2.length === 0 ? {} : {
+        attachments: attachments2.map(({ name, data }) => [
+          name,
+          Buffer.from(data, "base64").toString("base64")
+        ])
+      }
+    };
+    return createHash2("sha256").update(JSON.stringify(Object.entries(normalized).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0))).digest("hex");
+  };
+  const requestedTask = (input, principal) => {
+    if (input.requestId === undefined)
+      return null;
+    const saved = db.query("SELECT input_hash, task_id FROM task_requests WHERE requester_id = ? AND request_id = ?").get(principal === "owner" ? "owner" : principal.id, input.requestId.toLowerCase());
+    if (saved === null)
+      return null;
+    if (saved.input_hash !== requestHash(input))
+      throw new TaskRequestError({
+        status: 409,
+        message: "Request ID was already used with different task input"
+      });
+    if (saved.task_id === null)
+      throw new TaskRequestError({
+        status: 410,
+        message: "The original task is no longer retained; this request ID cannot be reused"
+      });
+    const task = db.query("SELECT * FROM tasks WHERE id = ?").get(saved.task_id);
+    if (task === null)
+      throw new Error(`Missing task ${saved.task_id} for retained request`);
+    return task;
+  };
+  const findDelegation = Effect14.fn("RelayStore.findDelegation")(function* (input, principal) {
+    const row = yield* Effect14.try({
+      try: () => requestedTask(input, principal),
+      catch: (cause) => cause instanceof TaskRequestError ? cause : operationError("RelayStore.findDelegation")(cause)
+    });
+    return row === null ? undefined : yield* taskFromRow(db, row);
+  });
   const recordTaskTraceEvent = (taskId, kind, detail, createdAt = now()) => {
     db.query(`INSERT INTO task_trace_events (task_id, kind, created_at, detail)
        VALUES (?, ?, ?, ?)`).run(taskId, kind, createdAt, detail);
@@ -814,7 +924,8 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     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`;
+    CASE WHEN status = 'needs_input' THEN NULL ELSE COALESCE(completed_at, updated_at) END AS completed_at,
+    CASE WHEN status = 'needs_input' THEN json_extract(clarifications_json, '$[#-1]') END AS input_request_json`;
   const queryOperation = (operationId) => db.query("SELECT * FROM device_operations WHERE id = ?").get(operationId);
   const getTask = Effect14.fn("RelayStore.getTask")(function* (taskId) {
     const row = yield* Effect14.try({
@@ -824,7 +935,8 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     if (row === null) {
       return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.getTask",
-        message: `Unknown task ${taskId}`
+        message: `Unknown task ${taskId}`,
+        missingRecord: "task"
       }));
     }
     return yield* taskFromRow(db, row);
@@ -855,8 +967,8 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     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),
+             AND status IN ('needs_input', 'completed', 'failed', 'cancelled')
+             ORDER BY COALESCE(completed_at, updated_at) ASC, id ASC LIMIT 21`).all(requesterId),
       catch: operationError("RelayStore.inboxFor")
     });
     return TaskInbox.make({
@@ -921,8 +1033,10 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
       ...task.workspace === undefined ? {} : { workspace: task.workspace },
       ...task.startedAt === undefined ? {} : { startedAt: task.startedAt },
       ...task.completedAt === undefined ? {} : { completedAt: task.completedAt },
+      ...task.expiresAt === undefined ? {} : { expiresAt: task.expiresAt },
       ...task.error === undefined ? {} : { error: task.error },
-      ...task.progress === undefined ? {} : { progress: task.progress }
+      ...task.progress === undefined ? {} : { progress: task.progress },
+      ...task.clarifications === undefined ? {} : { clarifications: task.clarifications }
     });
   });
   const listDevices = Effect14.fn("RelayStore.listDevices")(function* () {
@@ -937,6 +1051,54 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     });
     return yield* Effect14.forEach(rows, deviceFromRow);
   });
+  const listDevicePage = Effect14.fn("RelayStore.listDevicePage")(function* (after) {
+    const nextRow = yield* Effect14.try({
+      try: () => db.query(`SELECT devices.*,
+                  (SELECT COUNT(*) FROM tasks
+                   WHERE target_device_id = devices.id AND status = 'queued') AS queued_tasks,
+                  (SELECT MIN(created_at) FROM tasks
+                   WHERE target_device_id = devices.id AND status = 'queued') AS oldest_queued_at
+           FROM devices WHERE forgotten_at IS NULL AND devices.id > ?
+           ORDER BY devices.id LIMIT 1`),
+      catch: operationError("RelayStore.listDevicePage.query")
+    });
+    const devices = [];
+    const targetBytes = 2 * 1024 * 1024 - 1024;
+    let bytes = 0;
+    let cursor = after ?? "";
+    while (devices.length < maxDevicePageDevices) {
+      const row = yield* Effect14.try({
+        try: () => nextRow.get(cursor),
+        catch: operationError("RelayStore.listDevicePage.read")
+      });
+      if (row === null)
+        break;
+      const device = yield* deviceFromRow(row);
+      const size = Buffer.byteLength(JSON.stringify(device)) + (devices.length === 0 ? 0 : 1);
+      if (devices.length > 0 && bytes + size > targetBytes)
+        break;
+      devices.push(device);
+      bytes += size;
+      cursor = device.id;
+      if (bytes > targetBytes)
+        break;
+    }
+    const last = devices.at(-1);
+    const hasMore = last !== undefined && (yield* Effect14.try({
+      try: () => db.query("SELECT 1 AS found FROM devices WHERE forgotten_at IS NULL AND id > ? ORDER BY id LIMIT 1").get(last.id) !== null,
+      catch: operationError("RelayStore.listDevicePage.hasMore")
+    }));
+    const page = DevicePage.make({
+      devices,
+      ...hasMore && last !== undefined ? { nextCursor: last.id } : {}
+    });
+    if (Buffer.byteLength(JSON.stringify(page)) > maxDevicePageResponseBytes)
+      return yield* new PersistenceError({
+        operation: "RelayStore.listDevicePage",
+        message: "A device page exceeds the transfer limit"
+      });
+    return page;
+  });
   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,
@@ -992,7 +1154,8 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     if (row === null) {
       return yield* Effect14.fail(new PersistenceError({
         operation: "RelayStore.getOperation",
-        message: `Unknown device operation ${operationId}`
+        message: `Unknown device operation ${operationId}`,
+        missingRecord: "operation"
       }));
     }
     return yield* operationFromRow(row);
@@ -1150,13 +1313,15 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     yield* Effect14.try({
       try: () => db.transaction(() => {
         const timestamp = now();
-        const interrupted = db.query("SELECT id FROM tasks WHERE status IN ('assigned', 'running')").all();
+        const interrupted = db.query(`SELECT id, ${interruptedTaskStatus} AS status 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 = ?, progress_note = NULL, progress_at = NULL
+        db.query(`UPDATE tasks SET status = ${interruptedTaskStatus}, updated_at = ?, progress_note = NULL, progress_at = NULL,
+             dispatched_at = CASE WHEN provider = 'grok-bot' THEN dispatched_at
+               ELSE COALESCE(dispatched_at, started_at, updated_at) END
              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);
+          recordTaskTraceEvent(TaskId.make(task.id), task.status === "needs_input" ? "needs_input" : "requeued", "Relay restarted before the task completed", timestamp);
         }
         db.query("DELETE FROM auth_pairings WHERE expires_at <= ? OR used_at IS NOT NULL").run(timestamp);
         db.query("UPDATE auth_sessions SET revoked_at = ? WHERE revoked_at IS NULL AND roles_json LIKE '%,%'").run(timestamp);
@@ -1205,52 +1370,68 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     }
     return yield* deviceFromRow(row);
   });
-  const createDelegation2 = Effect14.fn("RelayStore.createDelegation")(function* (input, targetDeviceId, principal, providerSessionId) {
+  const createDelegation2 = Effect14.fn("RelayStore.createDelegation")(function* (input, targetDeviceId, principal, providerSessionId, requestedInput = input) {
     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")
     });
-    const timestamp = now();
-    const threadId = input.threadId ?? makeThreadId();
-    const task = Task.make({
-      id: makeTaskId(),
-      threadId,
-      prompt: input.prompt,
-      provider: input.provider ?? (input.botId === undefined ? "codex" : "grok-bot"),
-      ...input.botId === undefined ? {} : { botId: input.botId },
-      status: "queued",
-      targetDeviceId,
-      createdAt: timestamp,
-      updatedAt: timestamp,
-      ...input.context === undefined ? {} : { context: input.context },
-      ...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({
-      id: threadId,
-      title: input.title ?? input.prompt.slice(0, 72),
-      createdAt: timestamp,
-      updatedAt: timestamp
-    }) : undefined;
-    const message = Message.make({
-      id: makeMessageId(),
-      threadId,
-      role: "human",
-      authorName: sourceDeviceId === undefined ? "User" : "Remote agent",
-      content: input.prompt,
-      createdAt: timestamp,
-      taskId: task.id,
-      ...sourceDeviceId === undefined ? {} : { deviceId: sourceDeviceId }
-    });
-    yield* Effect14.try({
+    const submission = yield* Effect14.try({
       try: () => db.transaction(() => {
+        const existing = requestedTask(requestedInput, principal);
+        if (existing !== null)
+          return { existing };
+        if (input.expiresAt !== undefined) {
+          if (input.provider === "grok-bot" || input.botId !== undefined)
+            throw new TaskDeadlineError({
+              status: 400,
+              message: "Task deadlines require a coding provider"
+            });
+          if (taskDeadlinePassed(input))
+            throw new TaskDeadlineError({
+              status: 400,
+              message: "Task deadline must be in the future"
+            });
+        }
+        const timestamp = now();
+        const threadId = input.threadId ?? makeThreadId();
+        const task = Task.make({
+          id: makeTaskId(),
+          threadId,
+          prompt: input.prompt,
+          provider: input.provider ?? (input.botId === undefined ? "codex" : "grok-bot"),
+          ...input.botId === undefined ? {} : { botId: input.botId },
+          status: "queued",
+          targetDeviceId,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+          ...input.expiresAt === undefined ? {} : { expiresAt: Timestamp.make(new Date(input.expiresAt).toISOString()) },
+          ...input.context === undefined ? {} : { context: input.context },
+          ...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({
+          id: threadId,
+          title: input.title ?? input.prompt.slice(0, 72),
+          createdAt: timestamp,
+          updatedAt: timestamp
+        }) : undefined;
+        const message = Message.make({
+          id: makeMessageId(),
+          threadId,
+          role: "human",
+          authorName: sourceDeviceId === undefined ? "User" : "Remote agent",
+          content: input.prompt,
+          createdAt: timestamp,
+          taskId: task.id,
+          ...sourceDeviceId === undefined ? {} : { deviceId: sourceDeviceId }
+        });
         const outstanding = db.query(`SELECT COUNT(*) AS count FROM tasks WHERE target_device_id = ?
-               AND status IN ('queued', 'assigned', 'running', 'cancelling')`).get(targetDeviceId);
+               AND status IN ('queued', 'assigned', 'running', 'needs_input', 'cancelling')`).get(targetDeviceId);
         if ((outstanding?.count ?? 0) >= 100) {
           throw new Error(`Device ${targetDeviceId} has reached its outstanding task limit`);
         }
@@ -1262,8 +1443,8 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
         db.query(`INSERT INTO tasks (
               id, thread_id, prompt, context, provider, status, source_device_id,
               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);
+              provider_session_id, bot_id, created_at, updated_at, expires_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, task.expiresAt ?? null);
         for (const attachment of input.attachments ?? []) {
           const data = Buffer.from(attachment.data, "base64");
           if (data.length < 1 || data.length > maxAttachmentBytes) {
@@ -1271,16 +1452,20 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
           }
           db.query("INSERT INTO task_attachments (task_id, name, direction, data) VALUES (?, ?, 'input', ?)").run(task.id, attachment.name, data);
         }
+        if (requestedInput.requestId !== undefined) {
+          db.query("INSERT INTO task_requests (requester_id, request_id, input_hash, task_id) VALUES (?, ?, ?, ?)").run(requesterId, requestedInput.requestId.toLowerCase(), requestHash(requestedInput), task.id);
+        }
         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,
               task_id, device_id
             ) VALUES (?, ?, ?, 'chat', ?, ?, ?, ?, ?, ?)`).run(message.id, message.threadId, message.role, sourceDeviceId ?? "user", message.authorName, message.content, message.createdAt, message.taskId ?? null, message.deviceId ?? null);
         db.query("UPDATE threads SET updated_at = ? WHERE id = ?").run(timestamp, threadId);
+        return { created: task };
       })(),
-      catch: operationError("RelayStore.createDelegation")
+      catch: (cause) => cause instanceof TaskRequestError || cause instanceof TaskDeadlineError ? cause : operationError("RelayStore.createDelegation")(cause)
     });
-    return task;
+    return "existing" in submission ? yield* taskFromRow(db, submission.existing) : submission.created;
   });
   const threadContext2 = Effect14.fn("RelayStore.threadContext")(function* (threadId) {
     const threadRow = yield* Effect14.try({
@@ -1351,15 +1536,45 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     });
     return yield* getTask(taskId);
   });
+  const hasDispatchEvidence = Effect14.fn("RelayStore.hasDispatchEvidence")((taskId) => Effect14.try({
+    try: () => db.query("SELECT 1 FROM tasks WHERE id = ? AND dispatched_at IS NOT NULL").get(taskId) !== null,
+    catch: operationError("RelayStore.hasDispatchEvidence")
+  }));
+  const expireTask = Effect14.fn("RelayStore.expireTask")(function* (task) {
+    if (!taskDeadlinePassed(task) || ["cancelling", "completed", "failed", "cancelled"].includes(task.status))
+      return task;
+    const neverDispatched = task.status === "queued" && task.runId === undefined && task.startedAt === undefined && !(yield* hasDispatchEvidence(task.id));
+    return yield* transition(task.id, [task.status], {
+      status: neverDispatched ? "failed" : "cancelling",
+      error: taskDeadlineError,
+      ...neverDispatched ? { completedAt: now() } : {}
+    }, { kind: neverDispatched ? "failed" : "cancelling", detail: taskDeadlineError });
+  });
+  const expireTasks = Effect14.fn("RelayStore.expireTasks")(function* () {
+    const rows = yield* Effect14.try({
+      try: () => db.query(`SELECT * FROM tasks WHERE expires_at <= ? AND status IN ('queued', 'assigned', 'running', 'needs_input')
+         ORDER BY expires_at, id LIMIT 100`).all(now()),
+      catch: operationError("RelayStore.expireTasks")
+    });
+    return yield* Effect14.forEach(rows, (row) => taskFromRow(db, row).pipe(Effect14.flatMap(expireTask)));
+  });
   const assignTask = Effect14.fn("RelayStore.assignTask")(function* (taskId) {
-    const current = yield* getTask(taskId);
+    const current = yield* getTask(taskId).pipe(Effect14.flatMap(expireTask));
     if (current.status !== "queued") {
       return current;
     }
     const timestamp = now();
     yield* Effect14.try({
       try: () => db.transaction(() => {
-        const result = db.query(`UPDATE tasks SET status = 'assigned', updated_at = ?,
+        const result = db.query(`UPDATE tasks SET status = 'assigned', updated_at = ?, run_id = CASE
+                 WHEN dispatched_at IS NOT NULL OR started_at IS NOT NULL OR (
+                   provider = 'grok-bot' AND NOT EXISTS (
+                     SELECT 1 FROM devices, json_each(devices.capabilities_json) capability
+                     WHERE devices.id = tasks.target_device_id
+                       AND json_extract(capability.value, '$.id') = 'task-clarification'
+                   )
+                 )
+                   THEN run_id ELSE COALESCE(run_id, ?) END,
                  provider_session_id = CASE
                    WHEN provider = 'grok-bot' THEN NULL
                    WHEN started_at IS NULL THEN COALESCE((
@@ -1378,7 +1593,7 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
                  SELECT 1 FROM device_operations active
                  WHERE active.target_device_id = ?
                    AND active.status IN ('assigned', 'running')
-               )`).run(timestamp, taskId, current.targetDeviceId, taskId, taskSlot(current), current.targetDeviceId);
+               )`).run(timestamp, crypto.randomUUID(), taskId, current.targetDeviceId, taskId, taskSlot(current), current.targetDeviceId);
         if (result.changes === 1) {
           recordTaskTraceEvent(taskId, "assigned", "Relay dispatched the task over the device WebSocket", timestamp);
         }
@@ -1419,22 +1634,173 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     }
     return progress;
   });
-  const terminal = Effect14.fn("RelayStore.terminal")(function* (taskId, deviceId, status, result, error, providerSessionId, attachments2) {
+  const requestTaskInput = Effect14.fn("RelayStore.requestTaskInput")(function* (taskId, deviceId, input, turnFinished = false) {
+    const task = yield* getTask(taskId);
+    if (task.targetDeviceId !== deviceId) {
+      return yield* new TaskInputError({
+        status: 403,
+        message: "Only the target device can request input"
+      });
+    }
+    if (taskDeadlinePassed(task))
+      return yield* new TaskInputError({ status: 409, message: taskDeadlineError });
+    const active = task.status === "running" || turnFinished && (task.status === "queued" || task.status === "assigned");
+    if (!active || task.runId !== input.runId) {
+      return yield* new TaskInputError({
+        status: 409,
+        message: "Input can only be requested by the current running turn"
+      });
+    }
+    const row = yield* Effect14.try({
+      try: () => db.query("SELECT * FROM devices WHERE id = ?").get(deviceId),
+      catch: operationError("RelayStore.requestTaskInput.device")
+    });
+    const device = row === null ? undefined : yield* deviceFromRow(row);
+    if (!device?.capabilities.some((capability) => capability.id === "task-clarification")) {
+      return yield* new TaskInputError({
+        status: 409,
+        message: "Upgrade the target worker before requesting clarification"
+      });
+    }
+    const history = task.clarifications ?? [];
+    const pending = history.at(-1);
+    if (pending !== undefined && pending.answer === undefined) {
+      if (pending.question === input.question)
+        return pending;
+      return yield* new TaskInputError({
+        status: 409,
+        message: "This task already has an unanswered question"
+      });
+    }
+    if (history.length >= maxTaskClarifications) {
+      return yield* new TaskInputError({
+        status: 409,
+        message: `A task supports at most ${maxTaskClarifications} clarifications`
+      });
+    }
+    const question = TaskClarification.make({
+      id: ClarificationId.make(crypto.randomUUID()),
+      question: input.question,
+      at: now()
+    });
+    const changed = yield* Effect14.try({
+      try: () => db.transaction(() => {
+        const result = db.query(`UPDATE tasks SET clarifications_json = ?, updated_at = ?
+           WHERE id = ? AND status = ? AND run_id = ?
+             AND COALESCE(clarifications_json, '[]') = ?`).run(JSON.stringify([...history, question]), question.at, taskId, task.status, input.runId, JSON.stringify(history));
+        if (result.changes === 1)
+          recordTaskTraceEvent(taskId, "input_requested", "Worker requested clarification and is ending its turn", question.at);
+        return result.changes;
+      })(),
+      catch: operationError("RelayStore.requestTaskInput")
+    });
+    if (changed !== 1)
+      return yield* new TaskInputError({
+        status: 409,
+        message: "Task changed while requesting input; check its status"
+      });
+    return question;
+  });
+  const answerTaskInput = Effect14.fn("RelayStore.answerTaskInput")(function* (taskId, principal, input) {
+    const task = yield* getTask(taskId);
+    const requester = yield* Effect14.try({
+      try: () => queryTask(taskId)?.requester_id,
+      catch: operationError("RelayStore.answerTaskInput.requester")
+    });
+    if (principal !== "owner" && (principal.role !== "client" || requester !== principal.id)) {
+      return yield* new TaskInputError({
+        status: 403,
+        message: "Only the original requester or relay owner can answer"
+      });
+    }
+    if (taskDeadlinePassed(task))
+      return yield* new TaskInputError({ status: 409, message: taskDeadlineError });
+    const history = task.clarifications ?? [];
+    const question = history.at(-1);
+    if (task.status !== "needs_input" || question?.id !== input.requestId || question.answer !== undefined) {
+      return yield* new TaskInputError({
+        status: 409,
+        message: "This question is no longer awaiting an answer; check task status"
+      });
+    }
+    const timestamp = now();
+    const answered = TaskClarification.make({
+      ...question,
+      answer: { text: input.answer, at: timestamp }
+    });
+    const changed = yield* Effect14.try({
+      try: () => db.transaction(() => {
+        const result = db.query(`UPDATE tasks SET status = 'queued', run_id = ?, clarifications_json = ?, updated_at = ?,
+             result = NULL, error = NULL, completed_at = NULL, progress_note = NULL, progress_at = NULL,
+             started_at = CASE WHEN provider = 'grok-bot' THEN NULL ELSE started_at END,
+             dispatched_at = NULL
+           WHERE id = ? AND status = 'needs_input' AND clarifications_json = ?`).run(crypto.randomUUID(), JSON.stringify([...history.slice(0, -1), answered]), timestamp, taskId, JSON.stringify(history));
+        if (result.changes === 1) {
+          recordTaskTraceEvent(taskId, "input_answered", "Requester answered the worker's question", timestamp);
+          recordTaskTraceEvent(taskId, "queued", "Task queued to resume with the answer", timestamp);
+        }
+        return result.changes;
+      })(),
+      catch: operationError("RelayStore.answerTaskInput")
+    });
+    if (changed !== 1)
+      return yield* new TaskInputError({
+        status: 409,
+        message: "Task changed while answering; check its status"
+      });
+    return yield* getTask(taskId);
+  });
+  const matchesTaskRun = (task, runId) => task.runId === undefined || task.runId === runId || runId === undefined && (task.clarifications?.length ?? 0) === 0;
+  const terminal = Effect14.fn("RelayStore.terminal")(function* (taskId, deviceId, status, result, error, providerSessionId, attachments2, runId) {
     const current = yield* requireTarget(taskId, deviceId);
-    if (["completed", "failed", "cancelled"].includes(current.status)) {
+    if (!matchesTaskRun(current, runId) || current.status === "cancelling" && status !== "cancelled" || ["completed", "failed", "cancelled"].includes(current.status)) {
       return current;
     }
+    if (taskDeadlinePassed(current) && status !== "cancelled")
+      return yield* expireTask(current);
+    const deadlineExpired = taskDeadlinePassed(current) && (current.status !== "cancelling" || current.error === taskDeadlineError);
+    const finalStatus = status === "cancelled" && deadlineExpired ? "failed" : status;
+    const finalError = finalStatus === "failed" && deadlineExpired ? taskDeadlineError : error;
     const timestamp = now();
     yield* Effect14.try({
       try: () => db.transaction(() => {
+        const saveProviderSession = () => {
+          if (current.provider === "grok-bot" || providerSessionId === undefined)
+            return;
+          db.query(`INSERT INTO provider_sessions (thread_id, device_id, provider, session_id, updated_at)
+               VALUES (?, ?, ?, ?, ?)
+               ON CONFLICT(thread_id, device_id, provider) DO UPDATE SET
+               session_id = excluded.session_id, updated_at = excluded.updated_at`).run(current.threadId, deviceId, current.provider, providerSessionId, timestamp);
+        };
+        if (current.status === "needs_input" && status !== "cancelled") {
+          if (current.provider === "grok-bot" || providerSessionId === undefined)
+            return;
+          const updated2 = db.query(`UPDATE tasks SET provider_session_id = ?, updated_at = ?
+                 WHERE id = ? AND status = 'needs_input' AND run_id IS ?`).run(providerSessionId, timestamp, taskId, current.runId ?? null);
+          if (updated2.changes === 1)
+            saveProviderSession();
+          return;
+        }
+        if (status !== "cancelled" && current.clarifications?.at(-1)?.answer === undefined && (current.clarifications?.length ?? 0) > 0) {
+          const changed = db.query(`UPDATE tasks SET status = 'needs_input', provider_session_id = ?, updated_at = ?,
+               progress_note = NULL, progress_at = NULL
+               WHERE id = ? AND status = ? AND run_id IS ?`).run(current.provider === "grok-bot" ? null : providerSessionId ?? current.providerSessionId ?? null, timestamp, taskId, current.status, current.runId ?? null);
+          if (changed.changes === 1) {
+            saveProviderSession();
+            recordTaskTraceEvent(taskId, "needs_input", "Worker paused for clarification", timestamp);
+          }
+          return;
+        }
         const updated = db.query(`UPDATE tasks SET status = ?, result = ?, error = ?, provider_session_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);
+             AND status NOT IN ('completed', 'failed', 'cancelled')
+             AND (status <> 'needs_input' OR ? = 'cancelled')
+             AND (status <> 'cancelling' OR ? = 'cancelled') AND run_id IS ?`).run(finalStatus, result ?? null, finalError ?? null, current.provider === "grok-bot" ? null : providerSessionId ?? current.providerSessionId ?? null, timestamp, timestamp, taskId, status, status, current.runId ?? null);
         if (updated.changes !== 1) {
           return;
         }
         db.query("DELETE FROM task_attachments WHERE task_id = ? AND direction = 'output'").run(taskId);
-        if (status === "completed") {
+        if (finalStatus === "completed") {
           if ((attachments2?.length ?? 0) > maxTaskAttachments) {
             throw new Error(`A task supports at most ${maxTaskAttachments} output files`);
           }
@@ -1446,20 +1812,15 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
             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)
-               VALUES (?, ?, ?, ?, ?)
-               ON CONFLICT(thread_id, device_id, provider) DO UPDATE SET
-               session_id = excluded.session_id, updated_at = excluded.updated_at`).run(current.threadId, deviceId, current.provider, providerSessionId, timestamp);
-        }
-        const content = result ?? error;
+        recordTaskTraceEvent(taskId, finalStatus, finalStatus === "completed" ? "Target device completed the task" : finalStatus === "failed" ? "Target device reported a task failure" : "Target device acknowledged cancellation", timestamp);
+        saveProviderSession();
+        const content = result ?? finalError;
         if (content !== undefined) {
-          const role = status === "completed" ? "agent" : "system";
+          const role = finalStatus === "completed" ? "agent" : "system";
           db.query(`INSERT INTO messages (
                 id, thread_id, role, kind, author_id, author_name, content, created_at,
                 task_id, device_id
-              ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(makeMessageId(), current.threadId, role, status === "failed" ? "error" : "chat", deviceId, status === "completed" ? providerName(current.provider) : "Cohall", content, timestamp, taskId, deviceId);
+              ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(makeMessageId(), current.threadId, role, finalStatus === "failed" ? "error" : "chat", deviceId, finalStatus === "completed" ? providerName(current.provider) : "Cohall", content, timestamp, taskId, deviceId);
           db.query("UPDATE threads SET updated_at = ? WHERE id = ?").run(timestamp, current.threadId);
         }
         pruneTerminalHistory(taskId);
@@ -1468,16 +1829,19 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     });
     return yield* getTask(taskId);
   });
+  const pauseTaskForInput = Effect14.fn("RelayStore.pauseTaskForInput")(function* (taskId, deviceId, input) {
+    const task = yield* requireTarget(taskId, deviceId);
+    if (task.runId !== input.runId || task.status !== "queued" && task.status !== "assigned" && task.status !== "running")
+      return task;
+    return yield* requestTaskInput(taskId, deviceId, input, true).pipe(Effect14.andThen(terminal(taskId, deviceId, "completed", "", undefined, undefined, undefined, input.runId)), Effect14.catchTag("RelayStore.TaskInputError", (cause) => terminal(taskId, deviceId, "failed", undefined, cause.message, undefined, undefined, input.runId)));
+  });
   const requestCancellation = Effect14.fn("RelayStore.requestCancellation")(function* (taskId) {
-    const current = yield* getTask(taskId);
+    const current = yield* getTask(taskId).pipe(Effect14.flatMap(expireTask));
     if (["completed", "failed", "cancelled"].includes(current.status)) {
       return current;
     }
-    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")
-    }));
-    if (current.provider === "grok-bot" && (current.status !== "queued" || current.startedAt !== undefined || dispatched)) {
+    const dispatched = yield* hasDispatchEvidence(taskId);
+    if (current.provider === "grok-bot" && current.status !== "needs_input" && (current.status !== "queued" || current.startedAt !== undefined || dispatched)) {
       return yield* new PersistenceError({
         operation: "RelayStore.requestCancellation",
         message: "Stop this bot in Grok Bot; its gateway cannot cancel an individual Cohall request"
@@ -1487,7 +1851,8 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
       return current;
     }
     const timestamp = now();
-    return current.status === "queued" ? yield* transition(taskId, ["queued"], { status: "cancelled", completedAt: timestamp }, { kind: "cancelled", detail: "Client cancelled the task before dispatch" }) : yield* transition(taskId, ["assigned", "running"], {
+    const neverDispatched = current.status === "queued" && !dispatched && (current.provider === "grok-bot" || current.runId === undefined && current.startedAt === undefined);
+    return neverDispatched || current.status === "needs_input" && current.provider === "grok-bot" ? yield* transition(taskId, ["queued", "needs_input"], { status: "cancelled", completedAt: timestamp }, { kind: "cancelled", detail: "Client cancelled the task before dispatch" }) : yield* transition(taskId, ["queued", "assigned", "running", "needs_input"], {
       status: "cancelling"
     }, { kind: "cancelling", detail: "Client requested task cancellation" });
   });
@@ -1495,12 +1860,14 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
     const timestamp = now();
     yield* Effect14.try({
       try: () => db.transaction(() => {
-        const interrupted = db.query(`SELECT id FROM tasks WHERE target_device_id = ?
+        const interrupted = db.query(`SELECT id, ${interruptedTaskStatus} AS status FROM tasks WHERE target_device_id = ?
                AND status IN ('assigned', 'running')`).all(deviceId);
-        db.query(`UPDATE tasks SET status = 'queued', updated_at = ?, progress_note = NULL, progress_at = NULL
+        db.query(`UPDATE tasks SET status = ${interruptedTaskStatus}, updated_at = ?, progress_note = NULL, progress_at = NULL,
+             dispatched_at = CASE WHEN provider = 'grok-bot' THEN dispatched_at
+               ELSE COALESCE(dispatched_at, started_at, updated_at) END
              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);
+          recordTaskTraceEvent(TaskId.make(task.id), task.status === "needs_input" ? "needs_input" : "requeued", "Target device disconnected before task completion", timestamp);
         }
       })(),
       catch: operationError("RelayStore.requeueTasksFor")
@@ -1620,14 +1987,20 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
   return Service2.of({
     recover,
     listDevices,
+    listDevicePage,
     usage,
     forgetDevice,
     upsertDevice,
     heartbeat: (deviceId, status, bots) => updateDeviceStatus(deviceId, status, bots),
     markDeviceOffline: (deviceId) => updateDeviceStatus(deviceId, "offline"),
     createDelegation: createDelegation2,
+    expireTasks,
+    findDelegation,
     getTask,
     reportTaskProgress,
+    requestTaskInput,
+    pauseTaskForInput,
+    answerTaskInput,
     listAttachments,
     readAttachment,
     inboxFor,
@@ -1643,10 +2016,13 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
       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(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"),
+    acceptTask: (taskId, deviceId, runId) => requireTarget(taskId, deviceId).pipe(Effect14.flatMap((task) => matchesTaskRun(task, runId) ? transition(taskId, ["assigned"], { status: "running", startedAt: task.startedAt ?? now() }, {
+      kind: "running",
+      detail: task.startedAt === undefined ? "Target device accepted the task and started the provider" : "Target device accepted the task again"
+    }) : Effect14.succeed(task))),
+    finishTask: (taskId, deviceId, result, providerSessionId, attachments2, runId) => terminal(taskId, deviceId, "completed", result, undefined, providerSessionId, attachments2, runId),
+    failTask: (taskId, deviceId, error, runId) => terminal(taskId, deviceId, "failed", undefined, error, undefined, undefined, runId),
+    acknowledgeCancellation: (taskId, deviceId, runId) => terminal(taskId, deviceId, "cancelled", undefined, undefined, undefined, undefined, runId),
     requestCancellation,
     requeueTasksFor,
     createUpgradeOperations,
@@ -1699,10 +2075,18 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
           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, progress_note TEXT, progress_at TEXT
+          dispatched_at TEXT, progress_note TEXT, progress_at TEXT,
+          run_id TEXT, clarifications_json TEXT, expires_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);
+        CREATE TABLE IF NOT EXISTS task_requests (
+          requester_id TEXT NOT NULL, request_id TEXT NOT NULL, input_hash TEXT NOT NULL,
+          task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+          PRIMARY KEY(requester_id, request_id)
+        );
+        CREATE INDEX IF NOT EXISTS task_requests_retained_task
+          ON task_requests(task_id) WHERE task_id IS NOT NULL;
         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')),
@@ -1750,6 +2134,13 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
       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 === "expires_at"))
+      db.exec("ALTER TABLE tasks ADD COLUMN expires_at TEXT");
+    db.exec("CREATE INDEX IF NOT EXISTS tasks_pending_deadline ON tasks(expires_at) WHERE status IN ('queued', 'assigned', 'running', 'needs_input')");
+    if (!taskColumns.some((column) => column.name === "run_id"))
+      db.exec("ALTER TABLE tasks ADD COLUMN run_id TEXT");
+    if (!taskColumns.some((column) => column.name === "clarifications_json"))
+      db.exec("ALTER TABLE tasks ADD COLUMN clarifications_json TEXT");
     if (!taskColumns.some((column) => column.name === "progress_note")) {
       db.exec("ALTER TABLE tasks ADD COLUMN progress_note TEXT");
     }
@@ -1774,6 +2165,13 @@ var PersistenceError, TaskProgressError, Service2, operationError = (operation)
             WHERE provider = 'grok-bot' AND status NOT IN ('completed', 'failed', 'cancelled')`);
       })();
     }
+    db.exec(`UPDATE tasks SET dispatched_at = COALESCE(started_at, updated_at)
+        WHERE provider <> 'grok-bot' AND dispatched_at IS NULL AND run_id IS NULL
+          AND status NOT IN ('completed', 'failed', 'cancelled')
+          AND (status IN ('assigned', 'running') OR started_at IS NOT NULL OR EXISTS (
+            SELECT 1 FROM task_trace_events
+            WHERE task_id = tasks.id AND kind IN ('assigned', 'running')
+          ))`);
   },
   catch: operationError("RelayStore.migrate")
 }), layer2 = (path, retainedTerminalTasks = 1000) => Layer2.effect(Service2, Effect14.acquireRelease(Effect14.try({
@@ -1784,10 +2182,20 @@ var init_store = __esm(() => {
   init_src();
   init_database();
   init_store();
-  PersistenceError = class PersistenceError extends Schema15.TaggedErrorClass()("RelayStore.PersistenceError", { operation: Schema15.String, message: Schema15.String }) {
+  PersistenceError = class PersistenceError extends Schema15.TaggedErrorClass()("RelayStore.PersistenceError", {
+    operation: Schema15.String,
+    message: Schema15.String,
+    missingRecord: Schema15.optionalKey(Schema15.Literals(["task", "operation"]))
+  }) {
   };
   TaskProgressError = class TaskProgressError extends Schema15.TaggedErrorClass()("RelayStore.TaskProgressError", { status: Schema15.Literals([403, 409]), message: Schema15.String }) {
   };
+  TaskInputError = class TaskInputError extends Schema15.TaggedErrorClass()("RelayStore.TaskInputError", { status: Schema15.Literals([403, 409]), message: Schema15.String }) {
+  };
+  TaskDeadlineError = class TaskDeadlineError extends Schema15.TaggedErrorClass()("RelayStore.TaskDeadlineError", { status: Schema15.Literals([400, 409]), message: Schema15.String }) {
+  };
+  TaskRequestError = class TaskRequestError extends Schema15.TaggedErrorClass()("RelayStore.TaskRequestError", { status: Schema15.Literals([409, 410]), message: Schema15.String }) {
+  };
   Service2 = class Service2 extends Context2.Service()("@cohall/RelayStore") {
   };
 });
@@ -1802,7 +2210,7 @@ __export(exports_main, {
   canReadTaskAttachments: () => canReadTaskAttachments,
   canDispatchTaskToDevice: () => canDispatchTaskToDevice
 });
-import { Effect as Effect15, ManagedRuntime, Schema as Schema16 } from "effect";
+import { Effect as Effect15, ManagedRuntime, Schema as Schema16, Schedule as Schedule4 } 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";
@@ -1833,7 +2241,7 @@ var RequestError, relayListenOptions = (configuration, environment = process.env
   if (request.method === "GET" || request.method === "HEAD") {
     return Promise.resolve(undefined);
   }
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const chunks = [];
     let size = 0;
     const cleanup = () => {
@@ -1852,7 +2260,7 @@ var RequestError, relayListenOptions = (configuration, environment = process.env
     };
     const onEnd = () => {
       cleanup();
-      resolve5(Buffer.concat(chunks, size));
+      resolve6(Buffer.concat(chunks, size));
     };
     const onError = (cause) => {
       cleanup();
@@ -1939,6 +2347,11 @@ Content-Length: 0\r
   const resolvedInput = parent === undefined ? input : { ...input, threadId: parent.threadId };
   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");
+  if (input.expiresAt !== undefined && provider === "grok-bot")
+    return yield* new RequestError({
+      status: 400,
+      message: "Task deadlines require a coding provider"
+    });
   const hasAttachments = (input.attachments?.length ?? 0) > 0;
   if (hasAttachments && provider === "grok-bot") {
     return yield* new RequestError({
@@ -1950,7 +2363,7 @@ Content-Length: 0\r
     provider,
     ...input.botId === undefined ? {} : { botId: input.botId }
   });
-  const blocked = new Set(ancestors.filter((task) => !isTerminalTask(task) && taskSlot(task) === slot).map((task) => task.targetDeviceId));
+  const blocked = new Set(ancestors.filter((task) => !isTerminalTask(task) && task.status !== "needs_input" && taskSlot(task) === slot).map((task) => task.targetDeviceId));
   if (input.targetDeviceId !== undefined) {
     const target = devices.find((device) => device.id === input.targetDeviceId);
     if (target === undefined) {
@@ -1965,6 +2378,11 @@ Content-Length: 0\r
         message: `${target.name} does not advertise the ${provider} provider`
       });
     }
+    if (input.expiresAt !== undefined && !target.capabilities.some((capability) => capability.id === "task-deadlines"))
+      return yield* new RequestError({
+        status: 409,
+        message: `${target.name} does not support task deadlines; upgrade its Cohall worker`
+      });
     if (hasAttachments && !target.capabilities.some((capability) => capability.id === "task-attachments")) {
       return yield* new RequestError({
         status: 409,
@@ -1985,7 +2403,7 @@ Content-Length: 0\r
     }
     return { input: resolvedInput, targetDeviceId: target.id };
   }
-  const providerDevices = 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.expiresAt === undefined || device.capabilities.some((capability) => capability.id === "task-deadlines")) && (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({
@@ -1997,11 +2415,11 @@ 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" : 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`
+      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.expiresAt !== undefined ? `No Cohall device advertising the ${provider} provider supports task deadlines; 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 };
-}), 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 () => {
+}), canReadTaskAttachments = (principal, task) => principal === "owner" || principal.role === "client" || principal.deviceId === task.targetDeviceId, requiresClarificationSupport = (task) => (task.clarifications?.length ?? 0) > 0 || task.provider === "grok-bot" && task.runId !== undefined, canDispatchTaskToDevice = (task, device) => (task.expiresAt === undefined || device?.capabilities.some((capability) => capability.id === "task-deadlines") === true) && ((task.inputAttachmentNames?.length ?? 0) === 0 || device?.capabilities.some((capability) => capability.id === "task-attachments") === true) && (!requiresClarificationSupport(task) || device?.capabilities.some((capability) => capability.id === "task-clarification") === true), runRelay = async () => {
   const configuration = await Effect15.runPromise(loadEnvironmentConfiguration);
   process.umask(63);
   const runtime = ManagedRuntime.make(exports_store.layer(configuration.databasePath, configuration.historyTaskLimit));
@@ -2036,20 +2454,39 @@ Content-Length: 0\r
     const token = authorization.slice("Bearer ".length);
     return await authenticate(token, "client") ?? (allowDevice ? authenticate(token, "device") : undefined);
   };
+  const sendCancellation = (task) => {
+    hub.sendToDevice(task.targetDeviceId, SocketEvent.make({
+      _tag: "CancelTask",
+      taskId: task.id,
+      ...task.runId === undefined ? {} : { runId: task.runId }
+    }));
+  };
   const dispatch = async (task) => {
     const store = await run2(exports_store.Service);
-    if ((task.inputAttachmentNames?.length ?? 0) > 0) {
+    if (task.expiresAt !== undefined || (task.inputAttachmentNames?.length ?? 0) > 0 || requiresClarificationSupport(task)) {
       const devices = await Effect15.runPromise(store.listDevices());
       const target = devices.find((device) => device.id === task.targetDeviceId);
+      if (task.expiresAt !== undefined && !target?.capabilities.some((capability) => capability.id === "task-deadlines"))
+        return task;
+      if (requiresClarificationSupport(task) && !target?.capabilities.some((capability) => capability.id === "task-clarification"))
+        return task;
       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."));
+        return Effect15.runPromise(store.failTask(task.id, task.targetDeviceId, "Target worker no longer supports task file attachments. Upgrade the worker and retry.", task.runId));
       }
     }
+    if (!hub.hasDevice(task.targetDeviceId))
+      return task;
     const assigned = await Effect15.runPromise(store.assignTask(task.id));
     if (assigned.status !== "assigned") {
+      if (assigned.status === "cancelling")
+        sendCancellation(assigned);
       return assigned;
     }
-    if (hub.sendToDevice(assigned.targetDeviceId, SocketEvent.make({ _tag: "TaskAssigned", task: assigned }), assigned.provider === "grok-bot" ? () => Effect15.runSync(store.markTaskDispatched(assigned.id)) : undefined)) {
+    const assignment = SocketEvent.make({ _tag: "TaskAssigned", task: assigned });
+    if (Buffer.byteLength(JSON.stringify(assignment)) > maxSocketPayloadBytes) {
+      return Effect15.runPromise(store.failTask(assigned.id, assigned.targetDeviceId, "Task prompt, context, and clarification history exceed the 1 MiB transfer limit. Retry with a shorter prompt or context.", assigned.runId));
+    }
+    if (hub.sendToDevice(assigned.targetDeviceId, assignment, assigned.provider === "grok-bot" ? () => Effect15.runSync(store.markTaskDispatched(assigned.id)) : undefined)) {
       return assigned;
     }
     return Effect15.runPromise(store.rollbackAssignment(task.id));
@@ -2086,7 +2523,7 @@ Content-Length: 0\r
     }));
     for (const task of tasks) {
       if (task.status === "cancelling") {
-        hub.sendToDevice(deviceId, SocketEvent.make({ _tag: "CancelTask", taskId: task.id }));
+        sendCancellation(task);
       } else {
         await dispatch(task);
       }
@@ -2146,7 +2583,9 @@ Content-Length: 0\r
         _tag: "Connected",
         serverVersion: version,
         connectedAt: now(),
-        taskAttachments: true
+        taskAttachments: true,
+        taskClarification: true,
+        taskDeadlines: true
       })));
       return;
     }
@@ -2182,12 +2621,18 @@ Content-Length: 0\r
       sendError(socket, "device_hello_required", "Send DeviceHello before device events");
       return;
     }
-    const settle = (taskId) => {
-      socket.send(JSON.stringify(SocketEvent.make({ _tag: "TaskSettled", taskId })));
+    const settle = (taskId, runId) => {
+      socket.send(JSON.stringify(SocketEvent.make({
+        _tag: "TaskSettled",
+        taskId,
+        ...runId === undefined ? {} : { runId }
+      })));
     };
     const settleOperation = (operationId) => {
       socket.send(JSON.stringify(SocketEvent.make({ _tag: "OperationSettled", operationId })));
     };
+    const taskTerminal = event._tag === "TaskFinished" || event._tag === "TaskInputRequested" || event._tag === "TaskFailed" || event._tag === "TaskCancelled";
+    const operationTerminal = event._tag === "OperationFinished" || event._tag === "OperationFailed";
     const processed = await run2(Effect15.gen(function* () {
       const store = yield* exports_store.Service;
       switch (event._tag) {
@@ -2197,16 +2642,23 @@ Content-Length: 0\r
           }
           return;
         case "TaskAccepted":
-          yield* store.acceptTask(event.taskId, deviceId);
+          yield* store.acceptTask(event.taskId, deviceId, event.runId);
           return;
         case "TaskFinished":
-          yield* store.finishTask(event.taskId, deviceId, event.result, event.providerSessionId, event.attachments);
+          yield* store.finishTask(event.taskId, deviceId, event.result, event.providerSessionId, event.attachments, event.runId);
+          return;
+        case "TaskInputRequested": {
+          yield* store.pauseTaskForInput(event.taskId, deviceId, {
+            runId: event.runId,
+            question: event.question
+          });
           return;
+        }
         case "TaskFailed":
-          yield* store.failTask(event.taskId, deviceId, event.error);
+          yield* store.failTask(event.taskId, deviceId, event.error, event.runId);
           return;
         case "TaskCancelled":
-          yield* store.acknowledgeCancellation(event.taskId, deviceId);
+          yield* store.acknowledgeCancellation(event.taskId, deviceId, event.runId);
           return;
         case "OperationAccepted":
           yield* store.acceptOperation(event.operationId, deviceId);
@@ -2227,21 +2679,31 @@ Content-Length: 0\r
           return;
       }
     })).then(() => true).catch((cause) => {
+      if (cause instanceof exports_store.PersistenceError && (taskTerminal && cause.missingRecord === "task" || operationTerminal && cause.missingRecord === "operation"))
+        return true;
       sendError(socket, "event_failed", cause instanceof Error ? cause.message : String(cause));
       return false;
     });
-    if (processed && (event._tag === "TaskFinished" || event._tag === "TaskFailed" || event._tag === "TaskCancelled")) {
-      settle(event.taskId);
+    if (processed && taskTerminal) {
+      settle(event.taskId, event.runId);
       await dispatchPending(deviceId);
     }
-    if (processed && (event._tag === "OperationFinished" || event._tag === "OperationFailed")) {
+    if (processed && operationTerminal) {
       settleOperation(event.operationId);
       await dispatchPending(deviceId);
     }
   };
   const api = async (request, url) => {
     if (url.pathname === "/api/health" && request.method === "GET") {
-      return json({ ok: true, version, taskAttachments: true, taskProgress: true });
+      return json({
+        ok: true,
+        version,
+        taskAttachments: true,
+        taskProgress: true,
+        taskClarification: true,
+        taskDeadlines: true,
+        taskIdempotency: true
+      });
     }
     if (url.pathname === "/api/auth/pair" && request.method === "POST") {
       return run2(Effect15.gen(function* () {
@@ -2252,7 +2714,8 @@ Content-Length: 0\r
     }
     const attachmentRoute = request.method === "GET" && /^\/api\/tasks\/[^/]+\/attachments(?:\/[^/]+)?$/.test(url.pathname);
     const progressRoute = request.method === "POST" && /^\/api\/tasks\/[^/]+\/progress$/.test(url.pathname);
-    const principal = await principalFor(request, attachmentRoute || progressRoute);
+    const inputRoute = request.method === "POST" && /^\/api\/tasks\/[^/]+\/input$/.test(url.pathname);
+    const principal = await principalFor(request, attachmentRoute || progressRoute || inputRoute);
     if (principal === undefined) {
       return json({ error: "Unauthorized" }, 401);
     }
@@ -2277,6 +2740,10 @@ Content-Length: 0\r
         hub.closeSession(id);
         return json(session);
       }
+      if (url.pathname === "/api/devices/page" && request.method === "GET") {
+        const after = url.searchParams.get("after");
+        return json(yield* store.listDevicePage(after === null ? undefined : yield* pathId(DeviceId, after)));
+      }
       if (url.pathname === "/api/devices" && request.method === "GET") {
         return json(yield* store.listDevices());
       }
@@ -2314,9 +2781,13 @@ Content-Length: 0\r
         return json(forgotten);
       }
       if (url.pathname === "/api/tasks" && request.method === "POST") {
-        const { input, targetDeviceId: target } = yield* resolveDelegation(yield* body(request, decodeCreateTaskInput), sourceDeviceId);
+        const requestedInput = yield* body(request, decodeCreateTaskInput);
+        const existing = yield* store.findDelegation(requestedInput, principal);
+        if (existing !== undefined)
+          return json(existing);
+        const { input, targetDeviceId: target } = yield* resolveDelegation(requestedInput, 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, principal, providerSessionId);
+        const task2 = yield* store.createDelegation(input, target, principal, providerSessionId, requestedInput);
         return json(yield* Effect15.tryPromise(() => dispatch(task2)), 201);
       }
       if (url.pathname === "/api/inbox" && request.method === "GET") {
@@ -2386,11 +2857,35 @@ Content-Length: 0\r
         return json(yield* store.reportTaskProgress(id, deviceId, input.note));
       }
       const cancel2 = url.pathname.match(/^\/api\/tasks\/([^/]+)\/cancel$/);
+      const inputRequest = url.pathname.match(/^\/api\/tasks\/([^/]+)\/input$/);
+      if (request.method === "POST" && inputRequest?.[1] !== undefined) {
+        const id = yield* pathId(TaskId, inputRequest[1]);
+        const input = yield* body(request, decodeRequestTaskInput);
+        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 request input"
+          });
+        return json(yield* store.requestTaskInput(id, deviceId, input));
+      }
+      const answer = url.pathname.match(/^\/api\/tasks\/([^/]+)\/answer$/);
+      if (request.method === "POST" && answer?.[1] !== undefined) {
+        const task2 = yield* store.answerTaskInput(yield* pathId(TaskId, answer[1]), principal, yield* body(request, decodeAnswerTaskInput));
+        return json(yield* Effect15.tryPromise({
+          try: () => dispatch(task2),
+          catch: (cause) => new RequestError({
+            status: 500,
+            message: cause instanceof Error ? cause.message : String(cause)
+          })
+        }));
+      }
       if (request.method === "POST" && cancel2?.[1] !== undefined) {
         const id = yield* pathId(TaskId, cancel2[1]);
         const updated = yield* store.requestCancellation(id);
         if (updated.status === "cancelling") {
-          hub.sendToDevice(updated.targetDeviceId, SocketEvent.make({ _tag: "CancelTask", taskId: id }));
+          sendCancellation(updated);
         }
         return json(updated);
       }
@@ -2399,7 +2894,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 : cause._tag === "RelayStore.TaskProgressError" ? new RequestError({ status: cause.status, message: cause.message }) : new RequestError({
+    }).pipe(Effect15.mapError((cause) => cause instanceof RequestError ? cause : cause._tag === "RelayStore.TaskProgressError" || cause._tag === "RelayStore.TaskInputError" || cause._tag === "RelayStore.TaskDeadlineError" || cause._tag === "RelayStore.TaskRequestError" ? 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
     })));
@@ -2507,26 +3002,40 @@ Content-Length: 0\r
       websocketServer.emit("connection", websocket, request);
     });
   });
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     server.once("error", reject);
     server.listen(relayListenOptions(configuration), () => {
       server.off("error", reject);
-      resolve5();
+      resolve6();
     });
   });
   const address = server.address();
   const listener = typeof address === "string" ? address : address?.family === "IPv6" ? `[${address.address}]:${address.port}` : `${address?.address ?? configuration.host}:${address?.port ?? configuration.port}`;
   console.log(`Cohall relay listening on http://${listener}`);
+  const deadlineController = new AbortController;
+  const enforceDeadlines = Effect15.gen(function* () {
+    const store = yield* exports_store.Service;
+    const overdue = yield* store.expireTasks();
+    for (const task of overdue)
+      if (task.status === "cancelling")
+        sendCancellation(task);
+  }).pipe(Effect15.catch((cause) => Effect15.logError(cause)), Effect15.repeat({ schedule: Schedule4.spaced("1 second") }));
+  const deadlineWork = runtime.runPromise(enforceDeadlines, { signal: deadlineController.signal }).catch((cause) => {
+    if (!deadlineController.signal.aborted)
+      console.error(`Task deadline enforcement failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+  });
   let stopping = false;
   const shutdown = async () => {
     if (stopping) {
       return;
     }
     stopping = true;
+    deadlineController.abort();
+    await deadlineWork;
     for (const socket of websocketServer.clients) {
       socket.close(1001, "Relay shutting down");
     }
-    await new Promise((resolve5) => server.close(() => resolve5()));
+    await new Promise((resolve6) => server.close(() => resolve6()));
     websocketServer.close();
     await runtime.dispose();
   };
@@ -2578,7 +3087,14 @@ class RelayDecodeError extends Schema2.TaggedErrorClass()("RelayClient.DecodeErr
 class Service extends Context.Service()("@cohall/RelayClient") {
 }
 var normalizeBaseUrl = (url) => url.replace(/\/+$/, "");
-var jsonBody = async (response, operation) => {
+var compareDevices = (left, right) => {
+  const fold = (name) => name.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+  const byName = Buffer.compare(Buffer.from(fold(left.name)), Buffer.from(fold(right.name)));
+  return byName || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+};
+var maxJsonResponseBytes = 2 * 1024 * 1024;
+var maxTraceResponseBytes = 4 * 1024 * 1024;
+var jsonBody = async (response, operation, maxBytes = maxJsonResponseBytes) => {
   if (response.body === null) {
     throw new RelayDecodeError({ operation, message: "Relay returned an empty response" });
   }
@@ -2591,9 +3107,12 @@ var jsonBody = async (response, operation) => {
       break;
     }
     size += chunk.value.byteLength;
-    if (size > 2 * 1024 * 1024) {
+    if (size > maxBytes) {
       await reader.cancel();
-      throw new RelayDecodeError({ operation, message: "Relay response exceeded 2 MiB" });
+      throw new RelayDecodeError({
+        operation,
+        message: `Relay response exceeded ${maxBytes / (1024 * 1024)} MiB`
+      });
     }
     chunks.push(chunk.value);
   }
@@ -2622,42 +3141,80 @@ var responseMessage = async (response, operation) => {
 };
 var make = (options) => {
   const baseUrl = normalizeBaseUrl(options.baseUrl);
-  const request = (operation, path, schema, init) => Effect2.gen(function* () {
-    const response = yield* Effect2.tryPromise({
-      try: (signal) => fetch(`${baseUrl}${path}`, {
-        ...init,
-        signal: AbortSignal.any([signal, AbortSignal.timeout(30000)]),
-        headers: {
-          authorization: `Bearer ${options.token}`,
-          "content-type": "application/json",
-          ...init?.headers
+  const request = (operation, path, schema, init, maxResponseBytes = maxJsonResponseBytes) => Effect2.gen(function* () {
+    const json = yield* Effect2.tryPromise({
+      try: async (signal) => {
+        const response = await fetch(`${baseUrl}${path}`, {
+          ...init,
+          signal: AbortSignal.any([signal, AbortSignal.timeout(30000)]),
+          headers: {
+            authorization: `Bearer ${options.token}`,
+            "content-type": "application/json",
+            ...init?.headers
+          }
+        });
+        if (!response.ok) {
+          throw new RelayRequestError({
+            operation,
+            message: await responseMessage(response, operation),
+            status: response.status
+          });
         }
-      }),
-      catch: (cause) => new RelayRequestError({
+        return jsonBody(response, operation, maxResponseBytes).catch((cause) => {
+          throw cause instanceof RelayDecodeError ? cause : new RelayDecodeError({ operation, message: String(cause) });
+        });
+      },
+      catch: (cause) => cause instanceof RelayRequestError || cause instanceof RelayDecodeError ? cause : new RelayRequestError({
         operation,
         message: cause instanceof Error ? cause.message : String(cause)
       })
     });
-    if (!response.ok) {
-      return yield* Effect2.fail(new RelayRequestError({
-        operation,
-        message: yield* Effect2.promise(() => responseMessage(response, operation)),
-        status: response.status
-      }));
-    }
-    const json = yield* Effect2.tryPromise({
-      try: () => jsonBody(response, operation),
-      catch: (cause) => cause instanceof RelayDecodeError ? cause : new RelayDecodeError({ operation, message: String(cause) })
-    });
     return yield* Schema2.decodeUnknownEffect(schema)(json).pipe(Effect2.mapError((cause) => new RelayDecodeError({ operation, message: String(cause) })));
   });
+  const devicePage = (after) => request("RelayClient.devices", `/api/devices/page${after === undefined ? "" : `?after=${encodeURIComponent(after)}`}`, DevicePage, undefined, maxDevicePageResponseBytes);
   return Service.of({
-    devices: () => request("RelayClient.devices", "/api/devices", Schema2.Array(Device)),
+    devices: () => Effect2.gen(function* () {
+      const first = yield* devicePage().pipe(Effect2.catch((cause) => cause instanceof RelayRequestError && cause.status === 404 ? request("RelayClient.devices", "/api/devices", Schema2.Array(Device)) : Effect2.fail(cause)));
+      if (!("devices" in first))
+        return first;
+      const devices = [...first.devices];
+      let cursor = first.nextCursor;
+      while (cursor !== undefined) {
+        const page = yield* devicePage(cursor);
+        const next = page.devices[0];
+        if (next === undefined)
+          break;
+        if (next.id <= cursor)
+          return yield* new RelayDecodeError({
+            operation: "RelayClient.devices",
+            message: "Relay device page did not advance"
+          });
+        devices.push(...page.devices);
+        cursor = page.nextCursor;
+      }
+      return devices.sort(compareDevices);
+    }),
     forgetDevice: (deviceId) => request("RelayClient.forgetDevice", `/api/devices/${encodeURIComponent(deviceId)}/forget`, Device, { method: "POST" }),
     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) {
+      const hasAttachments = (input.attachments?.length ?? 0) > 0;
+      if (input.requestId !== undefined || input.expiresAt !== undefined || hasAttachments) {
+        const health = yield* request("RelayClient.taskSupport", "/api/health", Schema2.Struct({
+          taskIdempotency: Schema2.optionalKey(Schema2.Boolean),
+          taskDeadlines: Schema2.optionalKey(Schema2.Boolean),
+          taskAttachments: Schema2.optionalKey(Schema2.Boolean)
+        }));
+        if (input.requestId !== undefined && health.taskIdempotency !== true) {
+          return yield* new RelayRequestError({
+            operation: "RelayClient.createTask",
+            message: "Upgrade the Cohall relay before using task request IDs"
+          });
+        }
+        if (input.expiresAt !== undefined && health.taskDeadlines !== true)
+          return yield* new RelayRequestError({
+            operation: "RelayClient.createTask",
+            message: "Upgrade the Cohall relay before using task deadlines"
+          });
+        if (hasAttachments && health.taskAttachments !== true) {
           return yield* new RelayRequestError({
             operation: "RelayClient.createTask",
             message: "Upgrade the Cohall relay before sending file attachments"
@@ -2669,6 +3226,16 @@ var make = (options) => {
         body: JSON.stringify(input)
       });
     }),
+    requestTaskInput: (taskId, input) => Effect2.gen(function* () {
+      const health = yield* request("RelayClient.clarificationSupport", "/api/health", Schema2.Struct({ taskClarification: Schema2.optionalKey(Schema2.Boolean) }));
+      if (health.taskClarification !== true)
+        return yield* new RelayRequestError({
+          operation: "RelayClient.requestTaskInput",
+          message: "Upgrade the Cohall relay before requesting clarification"
+        });
+      return yield* request("RelayClient.requestTaskInput", `/api/tasks/${encodeURIComponent(taskId)}/input`, TaskClarification, { method: "POST", body: JSON.stringify(input) });
+    }),
+    answerTaskInput: (taskId, input) => request("RelayClient.answerTaskInput", `/api/tasks/${encodeURIComponent(taskId)}/answer`, Task, { method: "POST", body: JSON.stringify(input) }),
     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) }));
@@ -2730,7 +3297,7 @@ var make = (options) => {
     }),
     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),
+    traceTask: (taskId) => request("RelayClient.traceTask", `/api/tasks/${encodeURIComponent(taskId)}/trace`, TaskTrace, undefined, maxTraceResponseBytes),
     cancelTask: (taskId) => request("RelayClient.cancelTask", `/api/tasks/${encodeURIComponent(taskId)}/cancel`, Task, {
       method: "POST"
     }),
@@ -2973,7 +3540,7 @@ var prepareCommand = async (options) => {
     }
   }
 };
-var forEachJsonEvent = async (stdout, onEvent) => {
+var forEachJsonEvent = async (stdout, onEvent, onOversized) => {
   const limit = 1024 * 1024;
   let chunks = [];
   let size = 0;
@@ -2996,6 +3563,7 @@ var forEachJsonEvent = async (stdout, onEvent) => {
   const emit = () => {
     if (oversized) {
       oversized = false;
+      onOversized();
       return;
     }
     const line = Buffer.concat(chunks, size).toString("utf8");
@@ -3027,6 +3595,7 @@ var forEachJsonEvent = async (stdout, onEvent) => {
 var parseCodex = async (stdout, existingSession) => {
   let result = "";
   let sessionId = existingSession;
+  let discardedEvent = false;
   await forEachJsonEvent(stdout, (event) => {
     if (text(event.type) === "thread.started") {
       sessionId = text(event.thread_id) ?? sessionId;
@@ -3036,9 +3605,17 @@ var parseCodex = async (stdout, existingSession) => {
     }
     const item = record(event.item);
     if (text(item?.type) === "agent_message") {
-      result = text(item?.text) ?? text(item?.content) ?? result;
+      const content = text(item?.text) ?? text(item?.content);
+      result = content ?? result;
+      if (content !== undefined && content.length > 0)
+        discardedEvent = false;
     }
+  }, () => {
+    discardedEvent = true;
   });
+  if (discardedEvent) {
+    throw new Error("Provider JSON event exceeded 1 MiB without a later text response");
+  }
   return {
     result: result || "Codex completed the task without a text response.",
     ...sessionId === undefined ? {} : { sessionId }
@@ -3075,17 +3652,26 @@ var openCodeError = (event) => {
 var parseOpenCode = async (stdout, existingSession) => {
   let result = "";
   let sessionId = existingSession;
+  let discardedEvent = false;
   await forEachJsonEvent(stdout, (event) => {
     const failure = openCodeError(event);
     if (failure !== undefined) {
       throw new Error(failure);
     }
     sessionId = text(event.sessionID) ?? text(event.sessionId) ?? text(event.session_id) ?? text(record(event.info)?.sessionID) ?? sessionId;
+    if (text(event.type) !== "text")
+      return;
     const content = textFromPart(event.part) ?? textFromPart(event) ?? text(event.result);
     if (content !== undefined && content.length > 0) {
       result = content;
+      discardedEvent = false;
     }
+  }, () => {
+    discardedEvent = true;
   });
+  if (discardedEvent) {
+    throw new Error("Provider JSON event exceeded 1 MiB without a later text response");
+  }
   if (result.length === 0) {
     throw new Error("OpenCode produced no result; verify its authentication and use a supported project workspace");
   }
@@ -3171,7 +3757,8 @@ var run = (options) => Effect3.callback((resume, signal) => {
           ...providerEnvironment(),
           COHALL_PROVIDER: options.provider,
           COHALL_THREAD_ID: options.threadId,
-          ...options.taskId === undefined ? {} : { COHALL_TASK_ID: options.taskId }
+          ...options.taskId === undefined ? {} : { COHALL_TASK_ID: options.taskId },
+          ...options.runId === undefined ? {} : { COHALL_TASK_RUN_ID: options.runId }
         },
         extendEnv: false,
         detached: platform() !== "win32",
@@ -3263,7 +3850,7 @@ var run = (options) => Effect3.callback((resume, signal) => {
 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 join8, resolve as resolve3 } from "node:path";
+import { dirname as dirname6, join as join8, resolve as resolve4 } from "node:path";
 
 // skills/cohall/SKILL.md
 var SKILL_default = `---
@@ -3275,7 +3862,8 @@ 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, task state, and explicitly attached files.
+permissions. The relay carries prompts, questions and answers, 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.
@@ -3332,9 +3920,19 @@ Do not delegate ordinary local work when the other device provides no advantage.
    to use Codex on a computer; selecting a named bot infers \`grok-bot\`.
    Omit \`--target\` only when Cohall may choose a matching computer.
 
+   For a submission you may need to retry, generate and save a UUID v4 before
+   sending, then pass \`--request-id <uuid>\` or MCP \`delegate.request_id\`. Use a
+   device ID or \`@device-id/bot-id\` from discovery. After a lost response,
+   repeat the same input and ID with the same client credential to recover
+   the original task. Changed input returns 409; pruned task history returns
+   410 and the ID remains consumed. Check the original work before using a
+   new ID. With request IDs, specify a target or provider for thread follow-ups,
+   and explicitly select a Bot for Bot follow-ups.
+
 5. The command waits by default and returns JSON. Treat work as successful only
    when \`status\` is \`completed\`; use \`result\` in the current task. Report a
-   \`failed\`, \`cancelled\`, or \`cancelling\` state accurately.
+   \`failed\`, \`cancelled\`, or \`cancelling\` state accurately. Handle \`needs_input\`
+   through the clarification workflow below.
 
    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
@@ -3361,9 +3959,32 @@ 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.
+Answer pending questions using the workflow below. Read completed results with
+\`cohall status <task-id>\`, use them in the current work, then run
+\`cohall inbox ack <task-id>\`. Results that arrive after a wait times out appear
+in the same inbox.
+
+## Clarification
+
+When \`delegate\`, \`send\`, \`status\`, or \`wait\` returns \`needs_input\`, read
+\`input_request.question\` and \`input_request.id\`. Inbox entries use \`inputRequest\`.
+Answer from known conversation facts; ask the user if the answer is missing.
+Resume the existing task with the original requester credential:
+
+\`\`\`bash
+cohall answer <task-id> --request-id <question-id> --message 'Use main.'
+cohall wait <task-id> --timeout 1800
+\`\`\`
+
+MCP uses \`task_answer\` with \`task_id\`, \`request_id\`, and \`answer\`, then \`wait_task\`.
+Only a terminal result completes the handoff. Questions require an answer or
+cancellation, not an inbox acknowledgement. A stale question ID is rejected;
+read status again before answering.
+
+When receiving a delegated coding task and essential information is missing,
+run \`cohall request-input --question 'Your question'\` or \`task_request_input\`.
+The task and turn IDs are inherited. After the request succeeds, end the worker
+turn immediately; Cohall resumes the same task after the sender answers.
 
 ## Message named bots
 
@@ -3393,11 +4014,13 @@ Different bots and the computer's coding agent can run concurrently. Each
 individual bot processes one Cohall request at a time.
 
 When receiving a Cohall request inside a Grok Bot, finish with the \`cohall reply\`
-command supplied in the handoff. Pass the final answer through \`--message-file\`
-or \`--message -\` on stdin, then reply normally in chat. Use \`--error\` if unable
+command supplied in the handoff, including its \`--run-id\`. Pass the final answer
+through \`--message-file\` or \`--message -\` on stdin, then reply normally in chat. Use \`--error\` if unable
 to finish. This local receipt is what returns the result to the sending device;
 a chat message alone does not complete the Cohall task. The receipt survives
-worker restarts and works while the relay is temporarily unreachable.
+worker restarts and works while the relay is temporarily unreachable. For
+essential missing information, use that callback with \`--question\`, then end
+the Bot turn. Its resumed handoff supplies a new run ID and the sender's answer.
 
 ## Context and safety
 
@@ -3405,7 +4028,7 @@ worker restarts and works while the relay is temporarily unreachable.
 - Add new relevant developments to \`--context\` when following up from another chat.
 - Never send provider credentials, Cohall tokens, cookies, or browser-profile data.
 - Request a path only when the target advertises a matching workspace root.
-- Use the same thread for clarification instead of creating duplicate tasks.
+- Resume a clarification on its existing task instead of creating duplicate work.
 - Do not submit the same work through both CLI and MCP.
 - Respect user confirmation requirements for consequential actions on the target.
 
@@ -3426,16 +4049,25 @@ The relay itself must be reachable to accept a new task. Interrupted execution
 uses at-least-once delivery and may run again, so make consequential prompts safe
 to retry.
 
-The timeout error includes the task ID and last known status. The task continues
-unless cancelled:
+The timeout error includes the task ID and last known status. A wait timeout
+leaves the task running. When the user requires coding work to stop by a fixed
+time, pass \`--deadline <future-UTC-ISO-timestamp>\` to \`delegate\`, or \`deadline\`
+to MCP. The task's deadline includes queueing and clarification and remains
+unchanged on resume. Upgrade the requester, relay, and worker first. Named bots
+cannot use deadlines. An expired task fails with \`Task deadline exceeded\`.
+Tasks awaiting their first dispatch fail on the relay. Tasks that may have
+reached a worker stay \`cancelling\` until it acknowledges termination, including
+while it is offline. Without a deadline, stop work explicitly:
 
 \`\`\`bash
 cohall cancel <task-id>
 \`\`\`
 
-For coding agents, active cancellation is acknowledged by the target device;
-\`cancelling\` means the provider process has not confirmed termination yet.
-Queued bot tasks can be cancelled. Stop an active bot in Grok Bot; its gateway
+For coding agents, cancellation after possible dispatch stays \`cancelling\` until
+the target confirms termination, including paused tasks and tasks requeued after
+a disconnect. Tasks awaiting their first dispatch cancel immediately. Paused
+bot tasks and bot tasks awaiting their first dispatch can be cancelled.
+Stop an active bot in Grok Bot; its gateway
 cannot safely cancel an individual Cohall request.
 
 ## Read shared context
@@ -3469,9 +4101,10 @@ Trace a known task before inspecting machine-local service logs:
 cohall trace <task-id> --follow
 \`\`\`
 
-The trace is redacted and reports relay dispatch, device execution, retries,
-and terminal state. Use \`cohall thread <thread-id>\` when prompt and result
-history is relevant.
+The trace reports relay dispatch, device execution, retries, progress, questions,
+and terminal state. It omits prompts, final results, credentials, and provider
+session IDs; inspect progress and clarification text before sharing it.
+Use \`cohall thread <thread-id>\` when prompt and result history is relevant.
 
 If Cohall cannot connect or no target is available, run:
 
@@ -3509,7 +4142,8 @@ var ClientConfiguration = Schema4.Struct({
   relayUrl: Schema4.NonEmptyString,
   token: Schema4.NonEmptyString,
   mcpThreadId: Schema4.optionalKey(Schema4.String),
-  mcpTaskId: Schema4.optionalKey(Schema4.String)
+  mcpTaskId: Schema4.optionalKey(Schema4.String),
+  mcpTaskRunId: Schema4.optionalKey(TaskRunId)
 });
 var DeviceConfiguration = Schema4.Struct({
   relayUrl: Schema4.NonEmptyString,
@@ -3672,7 +4306,8 @@ var loadClientConfiguration = Effect4.tryPromise({
       relayUrl,
       token,
       ...process.env.COHALL_THREAD_ID === undefined ? {} : { mcpThreadId: process.env.COHALL_THREAD_ID },
-      ...process.env.COHALL_TASK_ID === undefined ? {} : { mcpTaskId: process.env.COHALL_TASK_ID }
+      ...process.env.COHALL_TASK_ID === undefined ? {} : { mcpTaskId: process.env.COHALL_TASK_ID },
+      ...process.env.COHALL_TASK_RUN_ID === undefined ? {} : { mcpTaskRunId: Schema4.decodeUnknownSync(TaskRunId)(process.env.COHALL_TASK_RUN_ID) }
     });
   },
   catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
@@ -3736,7 +4371,7 @@ import { Effect as Effect5, Schedule, Schema as Schema5 } from "effect";
 class DeviceSelectionError extends Schema5.TaggedErrorClass()("Cohall.DeviceSelectionError", { message: Schema5.String, devices: Schema5.Array(Schema5.String) }) {
 }
 
-class TaskWaitTimeoutError extends Schema5.TaggedErrorClass()("Cohall.TaskWaitTimeoutError", { message: Schema5.String, taskId: TaskId, status: TaskStatus }) {
+class TaskWaitTimeoutError extends Schema5.TaggedErrorClass()("Cohall.TaskWaitTimeoutError", { message: Schema5.String, taskId: TaskId, status: Schema5.optionalKey(TaskStatus) }) {
 }
 var TaskResult = Schema5.Struct({
   task_id: TaskId,
@@ -3748,7 +4383,9 @@ var TaskResult = Schema5.Struct({
   result: Schema5.optionalKey(Schema5.String),
   error: Schema5.optionalKey(Schema5.String),
   inbox_warning: Schema5.optionalKey(Schema5.String),
-  progress: Schema5.optionalKey(TaskProgress)
+  progress: Schema5.optionalKey(TaskProgress),
+  input_request: Schema5.optionalKey(TaskClarification),
+  expires_at: Schema5.optionalKey(TaskDeadline)
 });
 var matchingDevices = (devices, target) => {
   const value = target.replace(/^@/, "");
@@ -3792,22 +4429,33 @@ var selectTarget = Effect5.fn("Cohall.selectTarget")(function* (devices, target)
     ]
   });
 });
-var taskResult = (task) => TaskResult.make({
-  task_id: task.id,
-  thread_id: task.threadId,
-  status: task.status,
-  provider: task.provider,
-  target_device_id: task.targetDeviceId,
-  ...task.botId === undefined ? {} : { bot_id: task.botId },
-  ...task.result === undefined ? {} : { result: task.result },
-  ...task.error === undefined ? {} : { error: task.error },
-  ...task.progress === undefined ? {} : { progress: task.progress }
-});
-var acknowledgedTaskResult = async (client, task) => {
+var taskResult = (task) => {
+  const question = task.clarifications?.at(-1);
+  return TaskResult.make({
+    task_id: task.id,
+    thread_id: task.threadId,
+    status: task.status,
+    provider: task.provider,
+    target_device_id: task.targetDeviceId,
+    ...task.botId === undefined ? {} : { bot_id: task.botId },
+    ...task.result === undefined ? {} : { result: task.result },
+    ...task.error === undefined ? {} : { error: task.error },
+    ...task.expiresAt === undefined ? {} : { expires_at: task.expiresAt },
+    ...task.progress === undefined ? {} : { progress: task.progress },
+    ...task.status === "needs_input" && question !== undefined ? { input_request: question } : {}
+  });
+};
+var acknowledgedTaskResult = async (client, task, signal) => {
+  signal?.throwIfAborted();
   const result = taskResult(task);
-  const acknowledgementError = await Effect5.runPromise(client.acknowledgeCompletion(task.id)).then(() => {
+  if (!isTerminalTask(task))
+    return result;
+  const acknowledgementError = await Effect5.runPromise(client.acknowledgeCompletion(task.id), {
+    signal
+  }).then(() => {
     return;
   }).catch((cause) => {
+    signal?.throwIfAborted();
     if (cause instanceof RelayRequestError && cause.status === 404)
       return;
     return cause instanceof Error ? cause.message : String(cause);
@@ -3817,16 +4465,51 @@ var acknowledgedTaskResult = async (client, task) => {
     inbox_warning: `Result received, but the inbox could not be cleared: ${acknowledgementError}`
   });
 };
+var requestInput = Effect5.fn("Cohall.requestInput")(function* (client, configuration, question, taskId, runId) {
+  const id = taskId ?? (configuration.mcpTaskId === undefined ? undefined : yield* Schema5.decodeUnknownEffect(TaskId)(configuration.mcpTaskId));
+  if (id === undefined)
+    return yield* new RelayRequestError({
+      operation: "Cohall.requestInput",
+      message: "Task id is required outside delegated work"
+    });
+  const inheritedRun = id === configuration.mcpTaskId ? configuration.mcpTaskRunId : undefined;
+  const turn = runId ?? inheritedRun ?? (yield* client.getTask(id)).runId;
+  if (turn === undefined)
+    return yield* new RelayRequestError({
+      operation: "Cohall.requestInput",
+      message: "Task has no current worker turn; upgrade the relay and worker"
+    });
+  return yield* client.requestTaskInput(id, { runId: turn, question });
+});
 var createDelegation = Effect5.fn("Cohall.createDelegation")(function* (client, configuration, options) {
-  const devices = yield* client.devices();
-  if (devices.length === 0) {
+  if (options.requestId !== undefined && options.threadId !== undefined && options.target === undefined && options.provider === undefined && options.parentTaskId === undefined && configuration.mcpTaskId === undefined)
+    return yield* new DeviceSelectionError({
+      message: "With a request ID, select a target or provider explicitly for thread follow-ups",
+      devices: []
+    });
+  const directTarget = (() => {
+    if (options.requestId === undefined || options.target === undefined)
+      return;
+    const value = options.target.replace(/^@/, "");
+    const separator = value.indexOf("/");
+    const id = Schema5.decodeUnknownOption(DeviceId)(separator < 0 ? value : value.slice(0, separator));
+    if (id._tag === "None")
+      return;
+    return {
+      deviceId: id.value,
+      botId: separator < 0 ? undefined : Schema5.decodeUnknownSync(BotId)(value.slice(separator + 1))
+    };
+  })();
+  const needsDiscovery = directTarget === undefined && (options.requestId === undefined || options.target !== undefined);
+  const devices = needsDiscovery ? yield* client.devices() : [];
+  if (needsDiscovery && devices.length === 0) {
     return yield* new DeviceSelectionError({
       message: "No Cohall devices are registered",
       devices: []
     });
   }
-  let target = options.target === undefined ? undefined : yield* selectTarget(devices, options.target);
-  if (target === undefined && options.threadId !== undefined && options.provider === undefined && options.parentTaskId === undefined && configuration.mcpTaskId === undefined) {
+  let target = directTarget ?? (options.target === undefined ? undefined : yield* selectTarget(devices, options.target));
+  if (target === undefined && options.requestId === undefined && options.threadId !== undefined && options.provider === undefined && options.parentTaskId === undefined && configuration.mcpTaskId === undefined) {
     const context = yield* client.threadContext(options.threadId);
     const previous = context.tasks.findLast((task) => task.parentTaskId === undefined);
     if (previous === undefined && context.truncated) {
@@ -3857,6 +4540,7 @@ var createDelegation = Effect5.fn("Cohall.createDelegation")(function* (client,
   const parentTaskId = options.parentTaskId ?? (configuration.mcpTaskId === undefined ? undefined : yield* Schema5.decodeUnknownEffect(TaskId)(configuration.mcpTaskId));
   return yield* client.createTask({
     prompt: options.prompt,
+    ...options.requestId === undefined ? {} : { requestId: options.requestId },
     ...target === undefined ? {} : { targetDeviceId: target.deviceId },
     ...botId === undefined ? {} : { botId },
     ...options.threadId !== undefined ? { threadId: options.threadId } : inheritedThread === undefined ? {} : { threadId: ThreadId.make(inheritedThread) },
@@ -3864,30 +4548,35 @@ var createDelegation = Effect5.fn("Cohall.createDelegation")(function* (client,
     ...options.workspace === undefined ? {} : { workspace: options.workspace },
     ...provider === undefined ? {} : { provider },
     ...parentTaskId === undefined ? {} : { parentTaskId },
-    ...options.attachments === undefined ? {} : { attachments: options.attachments }
+    ...options.attachments === undefined ? {} : { attachments: options.attachments },
+    ...options.expiresAt === undefined ? {} : { expiresAt: options.expiresAt }
   });
 });
 var waitForTask = Effect5.fn("Cohall.waitForTask")(function* (client, initial, timeoutSeconds) {
-  const deadline = Date.now() + timeoutSeconds * 1000;
-  let task = initial;
-  while (!isTerminalTask(task)) {
-    if (Date.now() >= deadline) {
-      return yield* new TaskWaitTimeoutError({
-        message: `Task ${task.id} is still ${task.status} after ${timeoutSeconds} seconds`,
-        taskId: task.id,
-        status: task.status
-      });
+  const id = typeof initial === "string" ? initial : initial.id;
+  let task = typeof initial === "string" ? undefined : initial;
+  return yield* Effect5.gen(function* () {
+    if (task === undefined)
+      task = yield* client.getTask(id);
+    while (!isTerminalTask(task) && task.status !== "needs_input") {
+      yield* Effect5.sleep("1 second");
+      task = yield* client.getTask(id);
     }
-    yield* Effect5.sleep("1 second");
-    task = yield* client.getTask(task.id);
-  }
-  return task;
+    return task;
+  }).pipe(Effect5.timeoutOrElse({
+    duration: timeoutSeconds * 1000,
+    orElse: () => new TaskWaitTimeoutError({
+      message: task === undefined ? `Task ${id} did not return its status after ${timeoutSeconds} seconds` : `Task ${id} is still ${task.status} after ${timeoutSeconds} seconds`,
+      taskId: id,
+      ...task === undefined ? {} : { status: task.status }
+    })
+  }));
 });
 var followTaskTrace = Effect5.fn("Cohall.followTaskTrace")(function* (client, taskId, onTrace) {
   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"}:${trace.progress?.at ?? ""}:${trace.progress?.note ?? ""}`;
+    const nextRevision = `${trace.status}:${latest?.kind ?? "none"}:${latest?.at ?? "none"}:${trace.progress?.at ?? ""}:${trace.progress?.note ?? ""}:${JSON.stringify(trace.clarifications)}`;
     if (nextRevision === revision) {
       return Effect5.succeed(undefined);
     }
@@ -3973,11 +4662,18 @@ var Dispatch = Schema6.Struct({ taskId: TaskId });
 var Reply = Schema6.Union([
   Schema6.Struct({
     result: Schema6.String.check(Schema6.isMaxLength(131072)),
-    error: Schema6.optionalKey(Schema6.Never)
+    error: Schema6.optionalKey(Schema6.Never),
+    question: Schema6.optionalKey(Schema6.Never)
   }),
   Schema6.Struct({
     error: Schema6.NonEmptyString.check(Schema6.isMaxLength(16384)),
-    result: Schema6.optionalKey(Schema6.Never)
+    result: Schema6.optionalKey(Schema6.Never),
+    question: Schema6.optionalKey(Schema6.Never)
+  }),
+  Schema6.Struct({
+    question: RequestTaskInput.fields.question,
+    result: Schema6.optionalKey(Schema6.Never),
+    error: Schema6.optionalKey(Schema6.Never)
   })
 ]);
 var Receipt = Schema6.Struct({
@@ -3987,14 +4683,15 @@ var Receipt = Schema6.Struct({
 });
 var isMissing = (cause) => cause instanceof Error && ("code" in cause) && cause.code === "ENOENT";
 var alreadyExists = (cause) => cause instanceof Error && ("code" in cause) && cause.code === "EEXIST";
-var paths = (taskId) => {
+var paths = (taskId, runId) => {
   const id = Schema6.decodeUnknownSync(TaskId)(taskId);
   const directory = join3(dirname2(configurationPath()), "bot-replies");
+  const key = runId === undefined ? id : `${id}.${Schema6.decodeUnknownSync(TaskRunId)(runId)}`;
   return {
     directory,
-    pending: join3(directory, `${id}.pending.json`),
-    receipt: join3(directory, `${id}.reply.json`),
-    dispatch: join3(directory, `${id}.dispatch.json`)
+    pending: join3(directory, `${key}.pending.json`),
+    receipt: join3(directory, `${key}.reply.json`),
+    dispatch: join3(directory, `${key}.dispatch.json`)
   };
 };
 var readJson = async (path, limit) => {
@@ -4023,8 +4720,8 @@ var readJson = async (path, limit) => {
     await file.close();
   }
 };
-var pendingReply = async (taskId) => {
-  const value = await readJson(paths(taskId).pending, 4096);
+var pendingReply = async (taskId, runId) => {
+  const value = await readJson(paths(taskId, runId).pending, 4096);
   if (value === undefined)
     return;
   const decoded = Schema6.decodeUnknownResult(Pending)(value);
@@ -4067,7 +4764,7 @@ var prepareBotReply = async (task) => {
   if (task.provider !== "grok-bot" || task.botId === undefined) {
     throw new Error("Only a named Grok Bot task can receive a bot reply");
   }
-  const files = paths(task.id);
+  const files = paths(task.id, task.runId);
   await mkdir2(files.directory, { recursive: true, mode: 448 });
   await chmod3(files.directory, 448);
   const record2 = Pending.make({
@@ -4077,7 +4774,7 @@ var prepareBotReply = async (task) => {
     deadline: Date.now() + replyLifetimeMs
   });
   await publish(files.pending, record2);
-  const pending = await pendingReply(task.id);
+  const pending = await pendingReply(task.id, task.runId);
   if (pending === undefined || pending.botId !== task.botId || pending.threadId !== task.threadId) {
     throw new Error("Bot reply manifest does not match this task");
   }
@@ -4094,19 +4791,19 @@ var prepareBotReply = async (task) => {
     dispatched: dispatch !== undefined
   };
 };
-var claimBotDispatch = async (taskId) => {
-  const pending = await pendingReply(taskId);
+var claimBotDispatch = async (taskId, runId) => {
+  const pending = await pendingReply(taskId, runId);
   if (pending === undefined)
     throw new Error("No pending bot reply for this task");
   if (Date.now() >= pending.deadline)
     throw new Error("Bot reply deadline has expired");
-  return publish(paths(taskId).dispatch, { taskId });
+  return publish(paths(taskId, runId).dispatch, { taskId });
 };
-var readBotReply = async (taskId) => {
-  const pending = await pendingReply(taskId);
+var readBotReply = async (taskId, runId) => {
+  const pending = await pendingReply(taskId, runId);
   if (pending === undefined)
     return;
-  const value = await readJson(paths(taskId).receipt, 1024 * 1024);
+  const value = await readJson(paths(taskId, runId).receipt, 1024 * 1024);
   if (value === undefined)
     return;
   const decoded = Schema6.decodeUnknownResult(Receipt)(value);
@@ -4118,15 +4815,15 @@ var readBotReply = async (taskId) => {
   }
   return decoded.success.reply;
 };
-var writeBotReply = async (taskId, reply) => {
+var writeBotReply = async (taskId, reply, runId) => {
   const decoded = Schema6.decodeUnknownResult(Reply)(reply);
   if (decoded._tag === "Failure") {
-    throw new Error("Provide a result of at most 131072 characters or a nonempty error of at most 16384 characters");
+    throw new Error("Provide a result of at most 131072 characters, a nonempty error of at most 16384 characters, or a clarification question of at most 4096 UTF-8 bytes");
   }
-  const pending = await pendingReply(taskId);
+  const pending = await pendingReply(taskId, runId);
   if (pending === undefined)
     throw new Error("No pending bot reply for this task");
-  const existing = await readBotReply(taskId);
+  const existing = await readBotReply(taskId, runId);
   if (existing !== undefined) {
     if (JSON.stringify(existing) === JSON.stringify(decoded.success))
       return;
@@ -4135,15 +4832,15 @@ var writeBotReply = async (taskId, reply) => {
   const submittedAt = Date.now();
   if (submittedAt >= pending.deadline)
     throw new Error("Bot reply deadline has expired");
-  if (await publish(paths(taskId).receipt, { taskId, submittedAt, reply: decoded.success }))
+  if (await publish(paths(taskId, runId).receipt, { taskId, submittedAt, reply: decoded.success }))
     return;
-  const winner = await readBotReply(taskId);
+  const winner = await readBotReply(taskId, runId);
   if (JSON.stringify(winner) !== JSON.stringify(decoded.success)) {
     throw new Error("A different reply has already been submitted for this task");
   }
 };
-var cleanupBotReply = async (taskId) => {
-  const files = paths(taskId);
+var cleanupBotReply = async (taskId, runId) => {
+  const files = paths(taskId, runId);
   for (const path of [files.pending, files.receipt, files.dispatch]) {
     await unlink(path).catch((cause) => {
       if (!isMissing(cause))
@@ -4293,29 +4990,43 @@ var requireTime = (deadline) => {
     throw new Error(timeoutMessage);
 };
 var finishReply = (reply) => {
+  if (reply.question !== undefined)
+    return { result: "", question: reply.question };
   if (reply.error !== undefined)
     throw new Error(reply.error);
   if (reply.result === undefined)
     throw new Error("Grok Bot returned an invalid Cohall reply");
   return { result: reply.result };
 };
-var taskPrompt = (task, command) => [
-  task.prompt,
-  task.context === undefined ? "" : `Context:
+var taskPrompt = (task, command, supportsClarification) => {
+  const reply = `${command} reply ${task.id}${task.runId === undefined ? "" : ` --run-id ${task.runId}`}`;
+  return [
+    task.prompt,
+    task.context === undefined ? "" : `Context:
 ${task.context}`,
-  `This request came through Cohall. Thread: ${task.threadId}. Task: ${task.id}.`,
-  `You may use your own tools and delegate work to another Cohall device when the request calls for it. Discover devices with: ${command} devices`,
-  `Delegation example: ${command} delegate --thread ${task.threadId} --parent ${task.id} --target @device --provider codex --prompt 'Concrete task' --context 'Relevant context'`,
-  "When finished, hand the final answer back to Cohall so it reaches the requesting device. Write it to a UTF-8 file on this computer, then run:",
-  `${command} reply ${task.id} --message-file /absolute/path/to/your-answer.txt`,
-  `Alternatively pipe your answer into: ${command} reply ${task.id} --message -`,
-  `If you cannot complete this task, report the reason with: ${command} reply ${task.id} --error 'Reason'`,
-  "The reply command must succeed. Then send the same answer in this chat. A normal chat message alone does not complete the Cohall task."
-].filter(Boolean).join(`
+    `This request came through Cohall. Thread: ${task.threadId}. Task: ${task.id}.`,
+    `You may use your own tools and delegate work to another Cohall device when the request calls for it. Discover devices with: ${command} devices`,
+    `Delegation example: ${command} delegate --thread ${task.threadId} --parent ${task.id} --target @device --provider codex --prompt 'Concrete task' --context 'Relevant context'`,
+    "When finished, hand the final answer back to Cohall so it reaches the requesting device. Write it to a UTF-8 file on this computer, then run:",
+    `${reply} --message-file /absolute/path/to/your-answer.txt`,
+    `Alternatively pipe your answer into: ${reply} --message -`,
+    `If you cannot complete this task, report the reason with: ${reply} --error 'Reason'`,
+    ...supportsClarification && task.runId !== undefined ? [
+      `If essential information is missing, run ${reply} --question 'Your question' and end this turn. Cohall will pause the task and send a new turn with the answer. Do not send a final reply after asking.`,
+      ...(task.clarifications ?? []).flatMap((question) => question.answer === undefined ? [] : [
+        `Clarification question:
+${question.question}
+Sender's answer:
+${question.answer.text}`
+      ])
+    ] : [],
+    "The callback command must succeed. After submitting a final result, send the same answer in this chat. After submitting a question, end the turn. A normal chat message alone does not complete the Cohall task."
+  ].filter(Boolean).join(`
 
 `);
-var runGrokBot = async (path, task, signal) => {
-  const existing = await readBotReply(task.id);
+};
+var runGrokBot = async (path, task, signal, supportsClarification = false) => {
+  const existing = await readBotReply(task.id, task.runId);
   if (existing !== undefined)
     return finishReply(existing);
   const { deadline, command, dispatched } = await prepareBotReply(task);
@@ -4326,11 +5037,11 @@ var runGrokBot = async (path, task, signal) => {
   const lookup = async (lookupSignal = signal) => {
     if (path === undefined)
       throw new Error("Configure this device's Grok Bot gateway discovery file first");
-    return rpc(await readConnection(path), "promptAcceptanceStatus", { accountSlot: "host", agentId, clientNonce: task.id }, Acceptance, lookupSignal);
+    return rpc(await readConnection(path), "promptAcceptanceStatus", { accountSlot: "host", agentId, clientNonce: task.runId ?? task.id }, Acceptance, lookupSignal);
   };
   const waitForReply = (reconcile = false) => {
     const receipt = poll(async () => {
-      const receipt2 = await readBotReply(task.id);
+      const receipt2 = await readBotReply(task.id, task.runId);
       if (receipt2 !== undefined)
         return finishReply(receipt2);
       requireTime(deadline);
@@ -4359,7 +5070,7 @@ var runGrokBot = async (path, task, signal) => {
   if (acceptance.outcome === "unknown-durability")
     throw new Error("Grok Bot cannot confirm whether this task was accepted; check its conversation before retrying");
   if (acceptance.outcome === "not-found") {
-    const receipt = await readBotReply(task.id);
+    const receipt = await readBotReply(task.id, task.runId);
     if (receipt !== undefined)
       return finishReply(receipt);
     requireTime(deadline);
@@ -4371,20 +5082,20 @@ var runGrokBot = async (path, task, signal) => {
     acceptance = await lookup();
     if (acceptance.outcome === "not-found") {
       requireTime(deadline);
-      if (!await claimBotDispatch(task.id)) {
+      if (!await claimBotDispatch(task.id, task.runId)) {
         return waitForReply(true);
       }
       try {
         await rpc(connection, "sendPrompt", {
           agentId,
-          prompt: taskPrompt(task, command),
-          clientNonce: task.id,
+          prompt: taskPrompt(task, command, supportsClarification),
+          clientNonce: task.runId ?? task.id,
           directAddressedAcceptance: true
         }, SendResult, signal);
       } catch {
         if (signal.aborted)
           throw new Error("Stopped waiting for Grok Bot; its run may still be active");
-        const receipt2 = await readBotReply(task.id);
+        const receipt2 = await readBotReply(task.id, task.runId);
         if (receipt2 !== undefined)
           return finishReply(receipt2);
         return waitForReply(true);
@@ -4475,9 +5186,13 @@ var guidedSetupInput = async (options, prompter) => {
   const relayUrl = normalizeRelayUrl(options.relayUrl ?? await prompter.answer("Relay URL", existing?.relayUrl ?? "http://127.0.0.1:8787"));
   const credentials = credentialsForRelay(existing, relayUrl);
   const hasRequiredCredentials = credentials.clientToken !== undefined && (options.clientOnly || credentials.deviceToken !== undefined);
-  const workspaces = options.clientOnly ? existing?.workspaces ?? [] : options.workspaces.length > 0 ? options.workspaces : [await prompter.answer("Workspace root", existing?.workspaces[0] ?? options.cwd)];
+  let workspaces = options.clientOnly ? existing?.workspaces ?? [] : options.workspaces;
+  if (!options.clientOnly && workspaces.length === 0) {
+    const root = await prompter.answer("Workspace root", existing?.workspaces[0] ?? options.cwd);
+    workspaces = existing !== undefined && root === existing.workspaces[0] ? existing.workspaces : [root];
+  }
   const deviceName = options.clientOnly ? undefined : options.deviceName ?? await prompter.answer("Device name", existing?.deviceName ?? hostname2());
-  const providers = options.providers ?? (options.clientOnly ? "auto" : await prompter.answer("Providers", existing?.providers?.join(",") ?? "auto"));
+  const providers = options.providers ?? (options.clientOnly ? existing?.providers?.join(",") ?? "auto" : await prompter.answer("Providers", existing?.providers?.join(",") ?? "auto"));
   const token = options.token ?? (hasRequiredCredentials ? undefined : await prompter.secret("Pairing token"));
   if (!hasRequiredCredentials && (token === undefined || token.length === 0)) {
     throw new Error("A pairing token is required");
@@ -4508,21 +5223,21 @@ import {
   mkdir as mkdir5,
   mkdtemp as mkdtemp2,
   readFile as readFile3,
-  realpath as realpath4,
+  realpath as realpath3,
   rename as rename3,
   rm as rm3,
   stat as stat3,
   writeFile as writeFile5
 } from "node:fs/promises";
-import { basename, dirname as dirname5, join as join6, resolve as resolve2 } from "node:path";
+import { basename, dirname as dirname5, join as join6, resolve as resolve3 } from "node:path";
 import { backup as sqliteBackup, DatabaseSync } from "node:sqlite";
 import { WebSocket } from "ws";
 
 // apps/device/src/service.ts
 import { execFile as execFile2 } from "node:child_process";
-import { chmod as chmod5, mkdir as mkdir4, realpath as realpath3, writeFile as writeFile4 } from "node:fs/promises";
+import { chmod as chmod5, mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join5 } from "node:path";
 
 // apps/device/src/upgrade.ts
 import { Schema as Schema8 } from "effect";
@@ -4533,16 +5248,61 @@ import {
   chmod as chmod4,
   mkdir as mkdir3,
   readFile as readFile2,
+  readdir,
   realpath as realpath2,
   rename as rename2,
   rm as rm2,
   stat as stat2,
   writeFile as writeFile3
 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute2, join as join4, relative } from "node:path";
+import { delimiter as delimiter2, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve2 } from "node:path";
 import { platform as operatingSystem } from "node:os";
 var packageName = "@akshar5/cohall";
-var semanticVersion = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var minimumBunLookupVersion = "1.2.15";
+var semanticVersion = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var parseVersion = (value) => {
+  const [, major, minor, patch, prerelease] = semanticVersion.exec(value) ?? [];
+  if (major === undefined || minor === undefined || patch === undefined)
+    return;
+  const identifiers = prerelease?.split(".") ?? [];
+  if (identifiers.some((part) => /^0\d+$/.test(part)))
+    return;
+  return {
+    core: [BigInt(major), BigInt(minor), BigInt(patch)],
+    prerelease: identifiers
+  };
+};
+var compareVersions = (left, right) => {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (a === undefined || b === undefined) {
+    throw new Error(`Could not safely compare Cohall versions ${left} and ${right}`);
+  }
+  for (const [index, part] of a.core.entries()) {
+    const other = b.core[index];
+    if (other !== undefined && part !== other)
+      return part > other ? 1 : -1;
+  }
+  if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+    return Number(b.prerelease.length > 0) - Number(a.prerelease.length > 0);
+  }
+  for (let index = 0;index < Math.max(a.prerelease.length, b.prerelease.length); index += 1) {
+    const part = a.prerelease[index];
+    const other = b.prerelease[index];
+    if (part === undefined)
+      return -1;
+    if (other === undefined)
+      return 1;
+    if (part === other)
+      continue;
+    const numeric = /^\d+$/.test(part);
+    const otherNumeric = /^\d+$/.test(other);
+    if (numeric !== otherNumeric)
+      return numeric ? -1 : 1;
+    return numeric ? BigInt(part) > BigInt(other) ? 1 : -1 : part > other ? 1 : -1;
+  }
+  return 0;
+};
 var PackageManager = Schema8.Literals(["npm", "bun", "pnpm"]);
 var RestartReceipt = Schema8.Struct({
   version: Schema8.String,
@@ -4552,45 +5312,165 @@ var RestartReceipt = Schema8.Struct({
   restartedServices: Schema8.Array(Schema8.String),
   restartingService: Schema8.optionalKey(Schema8.String)
 });
+var pnpmEnvironment = () => Object.fromEntries([
+  ["COREPACK_ENABLE_PROJECT_SPEC", "0"],
+  ...["GLOBAL_DIR", "GLOBAL_BIN_DIR", "STORE_DIR"].flatMap((name) => {
+    const value = process.env[`COHALL_PNPM_${name}`];
+    return value === undefined ? [] : [
+      [`npm_config_${name.toLowerCase()}`, value],
+      [`pnpm_config_${name.toLowerCase()}`, value]
+    ];
+  })
+]);
 var normalizePath = (path) => path.replaceAll("\\", "/");
+var pnpmGlobalDirectory = /^(.*\/global\/v?\d+)\//;
 var normalizeUpgradeTarget = (target) => {
   if (target === undefined || target === "latest") {
     return "latest";
   }
   const normalized = target.startsWith("v") ? target.slice(1) : target;
-  if (!semanticVersion.test(normalized)) {
+  if (parseVersion(normalized) === undefined) {
     throw new Error("--to must be latest or an exact semantic version");
   }
   return normalized;
 };
 var deviceVersionWarning = (cliVersion, deviceVersion) => deviceVersion === undefined || deviceVersion === cliVersion ? undefined : `Running device daemon uses Cohall ${deviceVersion}, while this CLI is ${cliVersion}. Run upgrade through the executable configured by the device service.`;
-var packageInstallation = (canonicalEntrypoint, entrypoint = canonicalEntrypoint) => {
+var packageInstallation = (canonicalEntrypoint, entrypoint = canonicalEntrypoint, runtimePlatform = process.platform) => {
   const path = normalizePath(canonicalEntrypoint);
   const marker = `/node_modules/${packageName}/`;
   const packageIndex = path.lastIndexOf(marker);
   if (packageIndex === -1) {
     throw new Error("cohall upgrade requires a global npm, Bun, or pnpm installation; package-runner and source-checkout executions cannot upgrade themselves");
   }
-  if (path.includes("/.npm/_npx/") || path.includes("/.bunx/") || path.includes("/pnpm/dlx/") || path.includes("/dlx/")) {
+  if ([path, normalizePath(entrypoint)].some((candidate) => candidate.includes("/.npm/_npx/") || candidate.includes("/.bunx/") || candidate.includes("/dlx/"))) {
     throw new Error("This Cohall process is running from a temporary package-runner cache; install it globally before using cohall upgrade");
   }
   if (path.includes("/.bun/install/global/node_modules/")) {
     return { manager: "bun", entrypoint };
   }
-  if (path.includes("/pnpm/global/")) {
+  if (pnpmGlobalDirectory.test(path) || /\/v\d+\/links\//.test(path) || path.includes("/node_modules/.pnpm/") || pnpmGlobalDirectory.test(normalizePath(entrypoint))) {
     return { manager: "pnpm", entrypoint };
   }
   const nodeModulesParent = path.slice(0, packageIndex);
-  const prefix = nodeModulesParent.endsWith("/lib") ? nodeModulesParent.slice(0, -"/lib".length) : nodeModulesParent;
+  const prefix = runtimePlatform !== "win32" && nodeModulesParent.endsWith("/lib") ? nodeModulesParent.slice(0, -"/lib".length) : nodeModulesParent;
   return { manager: "npm", prefix, entrypoint };
 };
+var resolvePackageInstallation = async (entrypoint, options = {}) => {
+  const canonicalEntrypoint = await realpath2(entrypoint);
+  const runtimePlatform = options.platform ?? process.platform;
+  const installation = packageInstallation(canonicalEntrypoint, resolve2(entrypoint), runtimePlatform);
+  if (installation.manager !== "pnpm") {
+    const prefix = installation.prefix;
+    if (installation.manager === "npm" && prefix !== undefined) {
+      const packageEntry2 = join4(prefix, ...runtimePlatform === "win32" ? [] : ["lib"], "node_modules", packageName, "bin", "cohall.js");
+      const command = join4(prefix, ...runtimePlatform === "win32" ? [] : ["bin"], "cohall");
+      const globalCommand = runtimePlatform === "win32" ? await readFile2(`${command}.cmd`, "utf8").then((shim) => /"%dp0%\\node_modules\\@akshar5\\cohall\\bin\\cohall\.js"\s+%\*/i.test(shim)).catch(() => false) : await realpath2(command).catch(() => {
+        return;
+      }) === canonicalEntrypoint;
+      if (globalCommand && await realpath2(packageEntry2).catch(() => {
+        return;
+      }) === canonicalEntrypoint)
+        return {
+          ...installation,
+          canonicalEntrypoint,
+          pnpmExecutable: undefined,
+          globalRoot: undefined
+        };
+    }
+    const bun = await (options.resolveExecutable ?? trustedExecutable)("bun").catch(() => {
+      return;
+    });
+    if (bun !== undefined) {
+      const result2 = await (options.runner ?? defaultRunner).run(bun, ["pm", "ls", "--global"], 1e4);
+      const root2 = result2.stdout.split(/\r?\n/, 1)[0]?.match(/^(.*?) node_modules \(\d+(?: installed)?\)$/)?.[1];
+      if (result2.exitCode === 0 && root2 !== undefined && isAbsolute2(root2) && await realpath2(join4(root2, "node_modules", packageName, "bin", "cohall.js")).catch(() => {
+        return;
+      }) === canonicalEntrypoint)
+        return {
+          manager: "bun",
+          entrypoint: resolve2(entrypoint),
+          canonicalEntrypoint,
+          globalDir: root2,
+          pnpmExecutable: undefined,
+          globalRoot: undefined
+        };
+    }
+    throw new Error("This operation requires a verified global npm, Bun, or pnpm installation. Project-local packages cannot upgrade or install a service; run the global cohall command with its package manager's configuration.");
+  }
+  const lexicalPath = normalizePath(installation.entrypoint);
+  const globalRoot = lexicalPath.match(pnpmGlobalDirectory)?.[1] ?? lexicalPath.match(/^(.*\/v?\d+)\//)?.[1];
+  const globalEntrypointError = () => new Error("This operation requires a global pnpm entrypoint; project-local and shared-store executions cannot select a global installation. Run the global cohall command.");
+  if (globalRoot === undefined)
+    throw globalEntrypointError();
+  const selectedManager = process.env.COHALL_PNPM_EXECUTABLE ?? "pnpm";
+  const pnpmExecutable = options.resolveExecutable === undefined ? await trustedExecutable(selectedManager, { preserveSymlink: true }) : await options.resolveExecutable(selectedManager);
+  const result = await checked(options.runner ?? defaultRunner, {
+    command: pnpmExecutable,
+    arguments: ["root", "--global"],
+    environment: pnpmEnvironment()
+  }, 1e4);
+  const reported = normalizePath(result.stdout.trim().split(/\r?\n/).at(-1)?.trim() ?? "");
+  const root = reported.endsWith("/node_modules") ? dirname3(reported) : reported;
+  const selected = resolve2(globalRoot);
+  const configured = isAbsolute2(root) ? resolve2(root) : undefined;
+  if (configured === undefined || (process.platform === "win32" ? selected.toLowerCase() !== configured.toLowerCase() : selected !== configured))
+    throw globalEntrypointError();
+  const packageEntry = (root2) => join4(root2, "node_modules", packageName, "bin", "cohall.js");
+  const entries = await readdir(globalRoot, { withFileTypes: true });
+  const candidates = [
+    packageEntry(globalRoot),
+    ...entries.filter((entry) => entry.isSymbolicLink()).map((entry) => packageEntry(join4(globalRoot, entry.name)))
+  ];
+  for (const candidate of candidates) {
+    if (await realpath2(candidate).catch(() => {
+      return;
+    }) === canonicalEntrypoint)
+      return {
+        ...installation,
+        entrypoint: candidate,
+        canonicalEntrypoint,
+        globalDir: dirname3(globalRoot),
+        globalRoot,
+        pnpmExecutable
+      };
+  }
+  throw new Error("Could not find a stable pnpm global executable for this installation. Run the global cohall command, then use cohall service install before upgrading.");
+};
+var pnpmServiceDirectories = async (executable, globalRoot, runner = defaultRunner) => {
+  const query = async (arguments_) => {
+    const result = await checked(runner, { command: executable, arguments: arguments_, environment: pnpmEnvironment() }, 1e4);
+    const directory = result.stdout.trim().split(/\r?\n/).at(-1)?.trim() ?? "";
+    if (!isAbsolute2(directory))
+      throw new Error(`pnpm ${arguments_.join(" ")} did not report an absolute directory`);
+    return directory;
+  };
+  const [bin, store] = await Promise.all([
+    query(["bin", "--global"]),
+    query(["--dir", globalRoot, "--ignore-workspace", "store", "path"])
+  ]);
+  return { bin, store };
+};
 var packageInstallCommand = (installation, target) => {
   const specification = `${packageName}@${target}`;
   switch (installation.manager) {
     case "bun":
-      return { command: "bun", arguments: ["add", "--global", specification] };
+      return {
+        command: "bun",
+        arguments: ["add", "--global", specification],
+        ...installation.globalDir === undefined ? {} : { environment: { BUN_INSTALL_GLOBAL_DIR: installation.globalDir } }
+      };
     case "pnpm":
-      return { command: "pnpm", arguments: ["add", "--global", specification] };
+      return {
+        command: "pnpm",
+        arguments: [
+          "add",
+          "--global",
+          ...installation.globalDir === undefined ? [] : ["--global-dir", installation.globalDir],
+          ...process.env.COHALL_PNPM_GLOBAL_BIN_DIR === undefined ? [] : ["--global-bin-dir", process.env.COHALL_PNPM_GLOBAL_BIN_DIR],
+          specification
+        ],
+        environment: pnpmEnvironment()
+      };
     case "npm":
       return {
         command: "npm",
@@ -4629,36 +5509,38 @@ var isTrustedGroupWritablePath = (options) => {
   const writableRoot = options.writableRoot;
   return options.platform === "darwin" && writableRoot !== undefined && options.uid !== undefined && options.ownerUid === options.uid && options.ownerGid === macosAdminGroup && macosHomebrewRoots.some((root) => containsPath(root, writableRoot)) && containsPath(writableRoot, options.canonical) && containsPath(writableRoot, options.path);
 };
-var validateExecutable = async (candidate, installationRoot) => {
+var validateExecutable = async (candidate, installationRoot, preserveSymlink = false) => {
   const canonical = await realpath2(candidate);
   if (operatingSystem() === "win32") {
-    return canonical;
+    return preserveSymlink ? resolve2(candidate) : canonical;
   }
   const uid = process.getuid?.();
   const writableRoot = installationRoot === undefined ? undefined : await realpath2(installationRoot);
-  for (let path = canonical;; path = dirname3(path)) {
-    const metadata = await stat2(path);
-    const trustedGroupWritablePath = isTrustedGroupWritablePath({
-      platform: operatingSystem(),
-      canonical,
-      writableRoot,
-      path,
-      uid,
-      ownerUid: metadata.uid,
-      ownerGid: metadata.gid
-    });
-    if ((metadata.mode & 2) !== 0 || (metadata.mode & 16) !== 0 && !trustedGroupWritablePath) {
-      throw new Error(`Refusing executable beneath group- or world-writable path ${path}`);
-    }
-    if (uid !== undefined && metadata.uid !== 0 && metadata.uid !== uid && !isTrustedSystemPath(operatingSystem(), path)) {
-      throw new Error(`Refusing executable owned by another user at ${path}`);
-    }
-    const parent = dirname3(path);
-    if (parent === path) {
-      break;
+  for (const executablePath of preserveSymlink ? [canonical, resolve2(candidate)] : [canonical]) {
+    for (let path = executablePath;; path = dirname3(path)) {
+      const metadata = await stat2(path);
+      const trustedGroupWritablePath = isTrustedGroupWritablePath({
+        platform: operatingSystem(),
+        canonical,
+        writableRoot,
+        path,
+        uid,
+        ownerUid: metadata.uid,
+        ownerGid: metadata.gid
+      });
+      if ((metadata.mode & 2) !== 0 || (metadata.mode & 16) !== 0 && !trustedGroupWritablePath) {
+        throw new Error(`Refusing executable beneath group- or world-writable path ${path}`);
+      }
+      if (uid !== undefined && metadata.uid !== 0 && metadata.uid !== uid && !isTrustedSystemPath(operatingSystem(), path)) {
+        throw new Error(`Refusing executable owned by another user at ${path}`);
+      }
+      const parent = dirname3(path);
+      if (parent === path) {
+        break;
+      }
     }
   }
-  return canonical;
+  return preserveSymlink ? resolve2(candidate) : canonical;
 };
 var trustedExecutable = async (command, options = {}) => {
   const candidates = isAbsolute2(command) ? [command] : (process.env.PATH ?? "").split(delimiter2).filter(Boolean).flatMap((directory) => executableNames(command).map((name) => join4(directory, name)));
@@ -4668,7 +5550,7 @@ var trustedExecutable = async (command, options = {}) => {
     if (!available2)
       continue;
     try {
-      return await validateExecutable(path, options.writableRoot);
+      return await validateExecutable(path, options.writableRoot, options.preserveSymlink);
     } catch (cause) {
       failure ??= cause;
     }
@@ -4710,6 +5592,43 @@ var trustedServices = async (services, resolveExecutable) => {
   }
   return secured;
 };
+var ScheduledTaskAction = Schema8.Struct({
+  Execute: Schema8.NonEmptyString,
+  Arguments: Schema8.NonEmptyString
+});
+var powershellLiteral = "(?:[^'\\r\\n]|'')+";
+var scheduledTaskBootstrap = new RegExp([
+  "^\\$ErrorActionPreference = 'Stop'",
+  `\\$env:COHALL_CONFIG = '${powershellLiteral}'`,
+  `(?:\\$env:PNPM_HOME = '${powershellLiteral}'\\r?\\n\\$env:PATH = '${powershellLiteral}' \\+ ';' \\+ \\$env:PATH\\r?\\n)?(?:\\$env:COHALL_PNPM_EXECUTABLE = '${powershellLiteral}'\\r?\\n)?(?:\\$env:COHALL_PNPM_STORE_DIR = '${powershellLiteral}'\\r?\\n)?(?:\\$env:COHALL_PNPM_GLOBAL_DIR = '${powershellLiteral}'\\r?\\n)?(?:\\$env:COHALL_PNPM_GLOBAL_BIN_DIR = '${powershellLiteral}'\\r?\\n\\$env:PATH = '${powershellLiteral}' \\+ ';' \\+ \\$env:PATH\\r?\\n)?\\$env:PATH = '${powershellLiteral}' \\+ ';' \\+ \\$env:PATH`,
+  `& '(${powershellLiteral})' '(${powershellLiteral})' device`,
+  "exit \\$LASTEXITCODE(?:\\r?\\n)?$"
+].join("\\r?\\n"));
+var scheduledTaskEntrypoint = (output) => {
+  let value;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    return;
+  }
+  const decoded = Schema8.decodeUnknownOption(ScheduledTaskAction)(value);
+  if (decoded._tag === "None")
+    return;
+  const action = decoded.value;
+  if (!/(?:^|[/\\])(?:powershell|pwsh)\.exe$/i.test(action.Execute))
+    return;
+  const encoded = /^-NoLogo\s+-NoProfile\s+-NonInteractive\s+-EncodedCommand\s+([A-Za-z0-9+/]+={0,2})\s*$/i.exec(action.Arguments)?.[1];
+  if (encoded === undefined)
+    return;
+  const bytes = Buffer.from(encoded, "base64");
+  if (bytes.length % 2 !== 0 || bytes.toString("base64") !== encoded)
+    return;
+  const bootstrap = scheduledTaskBootstrap.exec(bytes.toString("utf16le"));
+  const node = bootstrap?.[1]?.replaceAll("''", "'");
+  if (node === undefined || !/(?:^|[/\\])node\.exe$/i.test(node))
+    return;
+  return bootstrap?.[2]?.replaceAll("''", "'");
+};
 var serviceCandidates = (runtimePlatform, uid) => {
   if (runtimePlatform === "linux") {
     const systemd = (manager, unit, device) => {
@@ -4769,6 +5688,18 @@ var serviceCandidates = (runtimePlatform, uid) => {
             "if ((Get-ScheduledTask -TaskName 'Cohall Device' -ErrorAction SilentlyContinue).State -eq 'Running') { exit 0 } else { exit 1 }"
           ]
         },
+        entrypoint: {
+          inspect: {
+            command: "powershell.exe",
+            arguments: [
+              "-NoProfile",
+              "-NonInteractive",
+              "-Command",
+              "@((Get-ScheduledTask -TaskName 'Cohall Device' -TaskPath '\\' -ErrorAction Stop).Actions) | Select-Object Execute, Arguments | ConvertTo-Json -Compress"
+            ]
+          },
+          parse: scheduledTaskEntrypoint
+        },
         restart: [
           {
             command: "schtasks.exe",
@@ -4783,13 +5714,14 @@ var serviceCandidates = (runtimePlatform, uid) => {
   return [];
 };
 var defaultRunner = {
-  run: async (command, arguments_, timeoutMs = 300000) => {
+  run: async (command, arguments_, timeoutMs = 300000, environment) => {
     const result = await execa2(command, arguments_, {
       encoding: "utf8",
       maxBuffer: 1024 * 1024,
       timeout: timeoutMs,
       windowsHide: true,
       stdin: "ignore",
+      ...environment === undefined ? {} : { env: environment },
       reject: false,
       stripFinalNewline: false
     });
@@ -4802,7 +5734,7 @@ var defaultRunner = {
   }
 };
 var checked = async (runner, invocation, timeoutMs) => {
-  const result = await runner.run(invocation.command, invocation.arguments, timeoutMs);
+  const result = await runner.run(invocation.command, invocation.arguments, timeoutMs, invocation.environment);
   if (result.exitCode === 0 || invocation.allowFailure === true) {
     return result;
   }
@@ -4820,7 +5752,7 @@ ${result.stderr}`))) {
   }
   return active;
 };
-var assertServiceInstallations = async (runner, services, canonicalEntrypoint, entrypoint) => {
+var assertServiceInstallations = async (runner, services, installation) => {
   for (const service of services) {
     if (service.entrypoint === undefined) {
       continue;
@@ -4829,15 +5761,19 @@ var assertServiceInstallations = async (runner, services, canonicalEntrypoint, e
     const serviceEntrypoint = service.entrypoint.parse(`${result.stdout}
 ${result.stderr}`);
     if (serviceEntrypoint === undefined) {
-      throw new Error(`Could not determine the executable used by active ${service.label}`);
+      throw new Error(`Could not determine the executable used by active ${service.label}${service.manager === "scheduled-task" ? ". Reinstall the task with cohall service install." : ""}`);
     }
     const canonicalServiceEntrypoint = await realpath2(serviceEntrypoint).catch((cause) => {
       throw new Error(`Could not resolve the executable used by active ${service.label}: ${cause instanceof Error ? cause.message : String(cause)}`);
     });
-    if (canonicalServiceEntrypoint === canonicalEntrypoint) {
+    if (canonicalServiceEntrypoint === installation.canonicalEntrypoint) {
+      const servicePath = resolve2(serviceEntrypoint);
+      const sameEntrypoint = service.manager === "scheduled-task" ? servicePath.toLowerCase() === installation.entrypoint.toLowerCase() : servicePath === installation.entrypoint;
+      if (installation.manager === "pnpm" && !sameEntrypoint)
+        throw new Error(`Active ${service.label} is pinned to a pnpm package directory that changes during upgrades. ${service.device ? "Run cohall service install through the global cohall command before upgrading." : `Update the relay service executable to ${installation.entrypoint} before upgrading.`}`);
       continue;
     }
-    throw new Error(`Active ${service.label} uses ${serviceEntrypoint}, but this Cohall CLI uses ${entrypoint}. Run the service executable's upgrade command so its installation is updated before restart.`);
+    throw new Error(`Active ${service.label} uses ${serviceEntrypoint}, but this Cohall CLI uses ${installation.entrypoint}. Run the service executable's upgrade command so its installation is updated before restart.`);
   }
 };
 var readReceipt = async (path) => readFile2(path, "utf8").then((content) => Schema8.decodeUnknownOption(RestartReceipt)(JSON.parse(content))).then((decoded) => decoded._tag === "Some" ? decoded.value : undefined).catch(() => {
@@ -4907,13 +5843,19 @@ var upgrade = async (options) => {
   const candidates = await trustedServices(serviceCandidates(runtimePlatform, uid), resolveExecutable);
   const statePath = options.statePath ?? restartReceiptPath();
   const previous = await readReceipt(statePath);
+  const entrypoint = options.entrypoint ?? process.argv[1];
+  if (entrypoint === undefined) {
+    throw new Error("Could not resolve the Cohall executable path");
+  }
+  const installation = await resolvePackageInstallation(entrypoint, {
+    runner,
+    platform: runtimePlatform,
+    ...options.resolveExecutable === undefined ? {} : { resolveExecutable }
+  });
   if (previous?.version === options.currentVersion && (target === "latest" || target === previous.version)) {
-    const byId = new Map(candidates.map((service) => [service.id, service]));
-    const pending = previous.pendingServices.flatMap((id) => {
-      const service = byId.get(id);
-      return service === undefined ? [] : [service];
-    });
+    const pending = candidates.filter((service) => previous.pendingServices.includes(service.id));
     const active = await activeServices(runner, pending);
+    await assertServiceInstallations(runner, active, installation);
     if (options.dryRun || !options.restart) {
       return {
         upgraded: previous.fromVersion !== previous.version,
@@ -4922,13 +5864,13 @@ var upgrade = async (options) => {
         requested_version: previous.version,
         package_manager: previous.packageManager,
         services_restarted: previous.restartedServices,
-        services_pending_restart: active.map((service) => service.id),
+        services_pending_restart: previous.pendingServices,
         resumed_after_restart: false,
         dry_run: options.dryRun
       };
     }
     const activeIds = new Set(active.map((service) => service.id));
-    const completedByRestart = pending.filter((service) => service.device && service.id === previous.restartingService && activeIds.has(service.id));
+    const completedByRestart = pending.filter((service) => options.delegated === true && service.device && service.id === previous.restartingService && activeIds.has(service.id));
     const completedIds = new Set(completedByRestart.map((service) => service.id));
     const remaining = active.filter((service) => !completedIds.has(service.id));
     let resumed = {
@@ -4944,8 +5886,10 @@ var upgrade = async (options) => {
     if (remaining.length > 0) {
       await writeReceipt(statePath, resumed);
       resumed = await restartServices(runner, remaining, statePath, resumed, options.delegated === true);
+    } else if (completedIds.size > 0) {
+      await writeReceipt(statePath, resumed);
     }
-    if (resumed.restartingService === undefined) {
+    if (resumed.pendingServices.length === 0) {
       await rm2(statePath, { force: true });
     }
     return {
@@ -4955,69 +5899,104 @@ var upgrade = async (options) => {
       requested_version: previous.version,
       package_manager: previous.packageManager,
       services_restarted: reportedRestartServices(resumed),
-      services_pending_restart: [],
+      services_pending_restart: resumed.pendingServices.filter((id) => id !== resumed.restartingService),
       resumed_after_restart: true,
       dry_run: false
     };
   }
-  const entrypoint = options.entrypoint ?? process.argv[1];
-  if (entrypoint === undefined) {
-    throw new Error("Could not resolve the Cohall executable path");
-  }
-  const canonicalEntrypoint = await realpath2(entrypoint);
-  const installation = packageInstallation(canonicalEntrypoint, entrypoint);
   const services = await activeServices(runner, candidates);
-  await assertServiceInstallations(runner, services, canonicalEntrypoint, entrypoint);
-  if (options.dryRun) {
+  await assertServiceInstallations(runner, services, installation);
+  const pendingServices = [
+    ...new Set([...previous?.pendingServices ?? [], ...services.map((service) => service.id)])
+  ];
+  const resolvePackageManager = () => {
+    if (installation.pnpmExecutable !== undefined)
+      return Promise.resolve(installation.pnpmExecutable);
+    return options.resolveExecutable === undefined ? trustedExecutable(installation.manager, installation.prefix === undefined ? {} : { writableRoot: installation.prefix }) : resolveExecutable(installation.manager);
+  };
+  let packageManagerExecutable;
+  let resolvedTarget = target;
+  if (target === "latest") {
+    packageManagerExecutable = await resolvePackageManager();
+    if (installation.manager === "bun") {
+      const information = await checked(runner, { command: packageManagerExecutable, arguments: ["--version"] }, 1e4);
+      if (compareVersions(information.stdout.trim(), minimumBunLookupVersion) < 0) {
+        throw new Error(`Latest upgrades require Bun ${minimumBunLookupVersion} or newer; upgrade Bun or use --to <exact-version>`);
+      }
+    }
+    const lookup = await checked(runner, {
+      command: packageManagerExecutable,
+      arguments: [
+        ...installation.manager === "bun" ? ["pm"] : [],
+        "view",
+        ...installation.manager === "pnpm" ? [] : ["--global"],
+        ...installation.prefix === undefined ? [] : ["--prefix", installation.prefix],
+        `${packageName}@latest`,
+        "version",
+        "--json"
+      ],
+      ...installation.manager === "pnpm" ? { environment: pnpmEnvironment() } : {}
+    }, 30000);
+    const latest = JSON.parse(lookup.stdout);
+    if (typeof latest !== "string" || parseVersion(latest) === undefined) {
+      throw new Error(`Could not resolve ${packageName}@latest to an exact semantic version`);
+    }
+    resolvedTarget = latest;
+  }
+  let nextVersion = await installedVersion(installation.entrypoint).catch((cause) => {
+    if (target === "latest") {
+      throw new Error("Could not verify the installed version before upgrading latest; use --to <version> to repair this installation", { cause });
+    }
+    return;
+  });
+  if (target === "latest" && (compareVersions(resolvedTarget, options.currentVersion) < 0 || compareVersions(resolvedTarget, nextVersion ?? options.currentVersion) < 0)) {
     return {
       upgraded: false,
       from_version: options.currentVersion,
-      installed_version: options.currentVersion,
+      installed_version: nextVersion ?? options.currentVersion,
       requested_version: target,
       package_manager: installation.manager,
       services_restarted: [],
-      services_pending_restart: options.restart ? services.map((service) => service.id) : [],
+      services_pending_restart: [],
       resumed_after_restart: false,
-      dry_run: true
+      dry_run: options.dryRun
     };
   }
-  let nextVersion = await installedVersion(entrypoint).catch(() => {
-    return;
-  });
-  if (nextVersion === undefined || target !== nextVersion) {
-    const install = packageInstallCommand(installation, target);
-    const installExecutable = options.resolveExecutable === undefined ? await trustedExecutable(install.command, installation.prefix === undefined ? {} : { writableRoot: installation.prefix }) : await resolveExecutable(install.command);
-    await checked(runner, { ...install, command: installExecutable });
-    nextVersion = await installedVersion(entrypoint);
-  }
-  if (target !== "latest" && nextVersion !== target) {
-    throw new Error(`Installed Cohall ${nextVersion}, expected ${target}`);
-  }
-  const upgraded = nextVersion !== options.currentVersion;
-  if (!options.restart || services.length === 0) {
-    await rm2(statePath, { force: true });
+  if (options.dryRun) {
     return {
-      upgraded,
+      upgraded: false,
       from_version: options.currentVersion,
-      installed_version: nextVersion,
+      installed_version: options.currentVersion,
       requested_version: target,
       package_manager: installation.manager,
       services_restarted: [],
-      services_pending_restart: options.restart ? [] : services.map((service) => service.id),
+      services_pending_restart: pendingServices,
       resumed_after_restart: false,
-      dry_run: false
+      dry_run: true
     };
   }
+  if (nextVersion === undefined || resolvedTarget !== nextVersion) {
+    const install = packageInstallCommand(installation, resolvedTarget);
+    const installExecutable = packageManagerExecutable ?? await resolvePackageManager();
+    await checked(runner, { ...install, command: installExecutable });
+    nextVersion = await installedVersion(installation.entrypoint);
+  }
+  if (nextVersion !== resolvedTarget) {
+    throw new Error(`Installed Cohall ${nextVersion}, expected ${resolvedTarget}`);
+  }
+  const upgraded = nextVersion !== options.currentVersion;
   const initial = {
     version: nextVersion,
     fromVersion: options.currentVersion,
     packageManager: installation.manager,
-    pendingServices: services.map((service) => service.id),
+    pendingServices,
     restartedServices: []
   };
-  await writeReceipt(statePath, initial);
-  const completed = await restartServices(runner, services, statePath, initial, options.delegated === true);
-  if (completed.restartingService === undefined) {
+  if (initial.pendingServices.length > 0) {
+    await writeReceipt(statePath, initial);
+  }
+  const completed = options.restart ? await restartServices(runner, services, statePath, initial, options.delegated === true) : initial;
+  if (completed.pendingServices.length === 0) {
     await rm2(statePath, { force: true });
   }
   return {
@@ -5027,7 +6006,7 @@ var upgrade = async (options) => {
     requested_version: target,
     package_manager: installation.manager,
     services_restarted: reportedRestartServices(completed),
-    services_pending_restart: [],
+    services_pending_restart: completed.pendingServices.filter((id) => id !== completed.restartingService),
     resumed_after_restart: false,
     dry_run: false
   };
@@ -5037,20 +6016,36 @@ var upgrade = async (options) => {
 var xml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 var systemdArgument = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"").replaceAll("%", "%%").replaceAll(`
 `, "\\n").replaceAll("\r", "\\r")}"`;
+var pnpmHomeDirectory = (platform4, home) => {
+  if (process.env.PNPM_HOME)
+    return process.env.PNPM_HOME;
+  if (process.env.XDG_DATA_HOME)
+    return join5(process.env.XDG_DATA_HOME, "pnpm");
+  if (platform4 === "darwin")
+    return join5(home, "Library", "pnpm");
+  if (platform4 !== "win32")
+    return join5(home, ".local", "share", "pnpm");
+  return process.env.LOCALAPPDATA ? join5(process.env.LOCALAPPDATA, "pnpm") : join5(home, ".pnpm");
+};
 var deviceServicePlan = (options) => {
+  const pnpmHome = options.pnpm?.home ?? (options.platform === "darwin" ? join5(options.home, "Library", "pnpm") : join5(options.home, ".local", "share", "pnpm"));
   const servicePath = [
     dirname4(options.nodeExecutable),
     join5(options.home, ".local", "bin"),
     join5(options.home, ".npm-global", "bin"),
     join5(options.home, ".bun", "bin"),
-    options.platform === "darwin" ? join5(options.home, "Library", "pnpm") : join5(options.home, ".local", "share", "pnpm"),
+    ...options.pnpm === undefined ? [] : [options.pnpm.bin],
+    join5(pnpmHome, "bin"),
+    pnpmHome,
     ...options.platform === "darwin" ? ["/opt/homebrew/bin"] : [],
     "/usr/local/bin",
     "/usr/bin",
     "/bin"
   ].join(":");
   if (options.platform === "linux") {
-    const path = join5(options.home, ".config", "systemd", "user", "cohall-device.service");
+    const configured = process.env.XDG_CONFIG_HOME;
+    const configHome = configured !== undefined && isAbsolute3(configured) ? configured : join5(options.home, ".config");
+    const path = join5(configHome, "systemd", "user", "cohall-device.service");
     return {
       file: {
         path,
@@ -5064,7 +6059,12 @@ Wants=network-online.target
 Type=simple
 Environment=${systemdArgument(`PATH=${servicePath}`)}
 Environment=${systemdArgument(`COHALL_CONFIG=${options.configPath}`)}
-ExecStart=${systemdArgument(options.entrypoint)} device
+${options.pnpm === undefined ? "" : `Environment=${systemdArgument(`PNPM_HOME=${options.pnpm.home}`)}
+Environment=${systemdArgument(`COHALL_PNPM_EXECUTABLE=${options.pnpm.executable}`)}
+Environment=${systemdArgument(`COHALL_PNPM_GLOBAL_DIR=${options.pnpm.globalDir}`)}
+Environment=${systemdArgument(`COHALL_PNPM_STORE_DIR=${options.pnpm.store}`)}
+Environment=${systemdArgument(`COHALL_PNPM_GLOBAL_BIN_DIR=${options.pnpm.bin}`)}
+`}ExecStart=${systemdArgument(options.entrypoint)} device
 Restart=always
 RestartSec=3
 UMask=0077
@@ -5108,7 +6108,17 @@ WantedBy=default.target
     <string>${xml(servicePath)}</string>
     <key>COHALL_CONFIG</key>
     <string>${xml(options.configPath)}</string>
-  </dict>
+${options.pnpm === undefined ? "" : `    <key>PNPM_HOME</key>
+    <string>${xml(options.pnpm.home)}</string>
+    <key>COHALL_PNPM_EXECUTABLE</key>
+    <string>${xml(options.pnpm.executable)}</string>
+    <key>COHALL_PNPM_STORE_DIR</key>
+    <string>${xml(options.pnpm.store)}</string>
+    <key>COHALL_PNPM_GLOBAL_DIR</key>
+    <string>${xml(options.pnpm.globalDir)}</string>
+    <key>COHALL_PNPM_GLOBAL_BIN_DIR</key>
+    <string>${xml(options.pnpm.bin)}</string>
+`}  </dict>
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
@@ -5138,8 +6148,8 @@ WantedBy=default.target
 var defaultRunner2 = {
   run: async (command, arguments_, timeoutMs = 60000) => {
     const executable = await trustedExecutable(command);
-    return new Promise((resolve2) => {
-      execFile2(executable, [...arguments_], { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: timeoutMs, windowsHide: true }, (error, stdout, stderr) => resolve2({
+    return new Promise((resolve3) => {
+      execFile2(executable, [...arguments_], { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: timeoutMs, windowsHide: true }, (error, stdout, stderr) => resolve3({
         exitCode: typeof error?.code === "number" ? error.code : error === null ? 0 : 1,
         stdout,
         stderr,
@@ -5156,12 +6166,22 @@ var checked2 = async (runner, command, arguments_, allowFailure = false) => {
   throw new Error(`${command} failed: ${result.stderr.trim() || result.stdout.trim() || result.error || `status ${result.exitCode}`}`);
 };
 var installDeviceService = async (options = {}) => {
-  const entrypoint = await realpath3(options.entrypoint ?? process.argv[1] ?? "");
-  packageInstallation(entrypoint);
+  const { entrypoint, canonicalEntrypoint, pnpmExecutable, globalDir, globalRoot } = await resolvePackageInstallation(options.entrypoint ?? process.argv[1] ?? "", {
+    ...options.platform === undefined ? {} : { platform: options.platform },
+    ...options.runner === undefined ? {} : { runner: options.runner },
+    ...options.resolveExecutable === undefined ? {} : { resolveExecutable: options.resolveExecutable }
+  });
   const platform4 = options.platform ?? process.platform;
+  const home = options.home ?? homedir3();
+  const pnpm = pnpmExecutable === undefined || globalDir === undefined || globalRoot === undefined ? undefined : {
+    home: pnpmHomeDirectory(platform4, home),
+    executable: pnpmExecutable,
+    globalDir,
+    ...await pnpmServiceDirectories(pnpmExecutable, globalRoot, options.runner)
+  };
   const runner = options.runner ?? defaultRunner2;
   if (platform4 === "win32") {
-    const script = join5(dirname4(dirname4(entrypoint)), "deploy", "windows", "install-device.ps1");
+    const script = join5(dirname4(dirname4(canonicalEntrypoint)), "deploy", "windows", "install-device.ps1");
     await checked2(runner, "powershell.exe", [
       "-NoProfile",
       "-ExecutionPolicy",
@@ -5173,7 +6193,19 @@ var installDeviceService = async (options = {}) => {
       "-Entrypoint",
       entrypoint,
       "-ConfigurationPath",
-      configurationPath()
+      configurationPath(),
+      ...pnpm === undefined ? [] : [
+        "-PnpmHome",
+        pnpm.home,
+        "-PnpmExecutable",
+        pnpm.executable,
+        "-PnpmStoreDir",
+        pnpm.store,
+        "-PnpmGlobalDir",
+        pnpm.globalDir,
+        "-PnpmGlobalBinDir",
+        pnpm.bin
+      ]
     ]);
     return { installed: "scheduled-task:Cohall Device" };
   }
@@ -5181,9 +6213,10 @@ var installDeviceService = async (options = {}) => {
   const plan = deviceServicePlan({
     platform: platform4,
     entrypoint,
-    home: options.home ?? homedir3(),
+    home,
     nodeExecutable: process.execPath,
     configPath: configurationPath(),
+    ...pnpm === undefined ? {} : { pnpm },
     ...uid === undefined ? {} : { uid }
   });
   await mkdir4(dirname4(plan.file.path), { recursive: true, mode: 448 });
@@ -5200,36 +6233,18 @@ var installDeviceService = async (options = {}) => {
 var restartDeviceService = async (options = {}) => {
   const platform4 = options.platform ?? process.platform;
   const runner = options.runner ?? defaultRunner2;
-  if (platform4 === "linux") {
-    const service = "cohall-device.service";
-    const check = await runner.run("systemctl", ["--user", "is-active", "--quiet", service], 1e4);
-    if (check.exitCode !== 0) {
-      return { running: false, restarted: false };
-    }
-    await checked2(runner, "systemctl", ["--user", "restart", service]);
-    return { running: true, restarted: true, service };
-  }
-  if (platform4 === "darwin") {
-    const service = "com.cohall.device";
-    const target = `gui/${options.uid ?? process.getuid?.() ?? 0}/${service}`;
-    const check = await runner.run("launchctl", ["print", target], 1e4);
-    if (check.exitCode !== 0) {
-      return { running: false, restarted: false };
-    }
-    await checked2(runner, "launchctl", ["kickstart", "-k", target]);
-    return { running: true, restarted: true, service };
+  const service = serviceCandidates(platform4, options.uid ?? process.getuid?.()).find((candidate) => candidate.device);
+  if (service === undefined)
+    return { running: false, restarted: false };
+  const check = await runner.run(service.check.command, service.check.arguments, 1e4);
+  if (check.exitCode !== 0 || service.activeOutput !== undefined && !service.activeOutput.test(`${check.stdout}
+${check.stderr}`)) {
+    return { running: false, restarted: false };
   }
-  if (platform4 === "win32") {
-    const service = "Cohall Device";
-    const check = await runner.run("schtasks.exe", ["/Query", "/TN", service], 1e4);
-    if (check.exitCode !== 0) {
-      return { running: false, restarted: false };
-    }
-    await checked2(runner, "schtasks.exe", ["/End", "/TN", service], true);
-    await checked2(runner, "schtasks.exe", ["/Run", "/TN", service]);
-    return { running: true, restarted: true, service };
+  for (const command of service.restart) {
+    await checked2(runner, command.command, command.arguments, command.allowFailure);
   }
-  return { running: false, restarted: false };
+  return { running: true, restarted: true, service: service.label };
 };
 
 // apps/device/src/relay-migration.ts
@@ -5266,7 +6281,7 @@ var verifyBackupDestinationParent = async (path) => {
   if (process.platform === "win32") {
     return;
   }
-  for (let current = await realpath4(path);; current = dirname5(current)) {
+  for (let current = await realpath3(path);; current = dirname5(current)) {
     const metadata = await stat3(current);
     const writableByOthers = (metadata.mode & 18) !== 0;
     const sticky = (metadata.mode & 512) !== 0;
@@ -5310,7 +6325,7 @@ var backupRelay = async (destinationInput) => {
   if (!await exists(sourceDatabase)) {
     throw new Error(`Relay database was not found at ${sourceDatabase}`);
   }
-  const destination = resolve2(destinationInput);
+  const destination = resolve3(destinationInput);
   if (await exists(destination)) {
     throw new Error(`Backup destination already exists: ${destination}`);
   }
@@ -5357,7 +6372,7 @@ var backupRelay = async (destinationInput) => {
   }
 };
 var restoreRelay = async (sourceInput) => {
-  const source = resolve2(sourceInput);
+  const source = resolve3(sourceInput);
   const sourceDatabase = join6(source, "cohall.db");
   const sourceOwnerToken = join6(source, "owner-token");
   const sourceManifest = join6(source, "manifest.json");
@@ -5502,9 +6517,9 @@ var switchRelay = async (options) => {
   }
   let service = { running: false, restarted: false };
   let warning;
-  if (updated && options.restart && deviceTokens.length > 0) {
+  if (options.restart && deviceTokens.length > 0) {
     service = await (options.restartService ?? restartDeviceService)().catch((cause) => {
-      warning = `Relay URL changed, but the device service could not restart: ${cause instanceof Error ? cause.message : String(cause)}`;
+      warning = `Relay URL is saved, but the device service could not restart: ${cause instanceof Error ? cause.message : String(cause)}. Retry cohall relay use ${relayUrl} to restart an active worker.`;
       return { running: true, restarted: false };
     });
   }
@@ -5521,9 +6536,33 @@ var switchRelay = async (options) => {
 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 {
+  lstat as lstat2,
+  mkdtemp as mkdtemp3,
+  mkdir as mkdir6,
+  open as open3,
+  readdir as readdir2,
+  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 readBoundedFile = async (handle) => {
+  const buffer = Buffer.allocUnsafe(maxAttachmentBytes + 1);
+  let offset = 0;
+  while (offset < buffer.length) {
+    const { bytesRead } = await handle.read({
+      buffer,
+      offset,
+      length: buffer.length - offset,
+      position: null
+    });
+    if (bytesRead === 0)
+      break;
+    offset += bytesRead;
+  }
+  return buffer.subarray(0, offset);
+};
 var readInputAttachments = async (paths2) => {
   if (paths2.length > maxTaskAttachments) {
     throw new Error(`A task supports at most ${maxTaskAttachments} input files`);
@@ -5546,7 +6585,7 @@ var readInputAttachments = async (paths2) => {
       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();
+      const data = await readBoundedFile(handle);
       if (data.length < 1 || data.length > maxAttachmentBytes) {
         throw new Error(`Attachment ${name} changed size while reading`);
       }
@@ -5556,31 +6595,32 @@ var readInputAttachments = async (paths2) => {
     }
   }));
 };
-var prepareTaskFiles = async (configuration, taskId, inputNames, signal) => {
+var prepareTaskFiles = Effect9.fn("TaskFiles.prepare")(function* (configuration, taskId, inputNames) {
   const client = exports_src.make({ baseUrl: configuration.relayUrl, token: configuration.token });
-  const root = await mkdtemp3(join7(tmpdir2(), "cohall-task-"));
+  const root = yield* Effect9.acquireRelease(Effect9.tryPromise({
+    try: () => mkdtemp3(join7(tmpdir2(), "cohall-task-")),
+    catch: (cause) => cause
+  }), (root2) => Effect9.promise(() => rm4(root2, { recursive: true, force: true })));
   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;
+  yield* Effect9.tryPromise({ try: () => mkdir6(input), catch: (cause) => cause }).pipe(Effect9.uninterruptible);
+  yield* Effect9.tryPromise({ try: () => mkdir6(output), catch: (cause) => cause }).pipe(Effect9.uninterruptible);
+  for (const name of inputNames) {
+    const data = yield* client.readAttachment(taskId, name);
+    yield* Effect9.tryPromise({
+      try: () => writeFile6(join7(input, name), data, { flag: "wx", mode: 384 }),
+      catch: (cause) => cause
+    }).pipe(Effect9.uninterruptible);
   }
-};
+  return {
+    input,
+    output,
+    inputNames,
+    collectOutputs: () => collectOutputs(output)
+  };
+});
 var collectOutputs = async (directory) => {
-  const entries = await readdir(directory, { withFileTypes: true });
+  const entries = await readdir2(directory, { withFileTypes: true });
   if (entries.length > maxTaskAttachments) {
     throw new Error(`A task can return at most ${maxTaskAttachments} files`);
   }
@@ -5603,7 +6643,7 @@ var collectOutputs = async (directory) => {
       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();
+      const data = await readBoundedFile(handle);
       if (data.length < 1 || data.length > maxAttachmentBytes) {
         throw new Error(`Output ${name} changed size while reading`);
       }
@@ -5653,6 +6693,7 @@ var valueOptions = new Set([
   "attach",
   "context",
   "context-file",
+  "deadline",
   "direction",
   "grok-gateway",
   "error",
@@ -5665,9 +6706,12 @@ var valueOptions = new Set([
   "parent",
   "prompt",
   "prompt-file",
+  "question",
+  "request-id",
   "provider",
   "providers",
   "relay",
+  "run-id",
   "sandbox",
   "target",
   "thread",
@@ -5704,11 +6748,13 @@ Usage:
   cohall config
   cohall devices
   cohall progress [task-id] --message <note>
+  cohall request-input [task-id] --question <text> [--run-id uuid]
+  cohall answer <task-id> --request-id uuid --message <text>
   cohall bots
   cohall send [@device-or-bot] [prompt] [delegate options]
   cohall delegate [prompt] [--target @device-or-bot] [--provider provider]
                   [--context text] [--thread uuid] [--parent task-id] [--workspace path]
-                  [--attach path] [--timeout seconds] [--no-wait]
+                  [--attach path] [--request-id uuid] [--timeout seconds] [--deadline UTC-timestamp] [--no-wait]
   cohall status <task-id>
   cohall inbox [ack <task-id>]
   cohall trace <task-id> [--follow]
@@ -5716,7 +6762,7 @@ Usage:
   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 reply <task-id> [--run-id uuid] --message-file path | --message text | --message - | --error text | --question text
   cohall thread <thread-id>
   cohall pair [--label name] [--client-only]
   cohall sessions
@@ -5911,17 +6957,21 @@ var printSkill = () => console.log(SKILL_default.trimEnd());
 var runCli = async (command, raw) => {
   const arguments_ = parseArguments(raw);
   if (command === "reply") {
-    allowOptions(arguments_, ["message", "message-file", "error"]);
+    allowOptions(arguments_, ["message", "message-file", "error", "question", "run-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");
-    }
-    const message = error === undefined ? await readInput(arguments_, "message") : undefined;
-    if (error === undefined && message === undefined) {
-      throw new Error("A bot reply requires --message, --message-file, or --error");
-    }
-    await writeBotReply(id, error === undefined ? { result: message ?? "" } : { error });
+    const question = option(arguments_, "question");
+    const rawRunId = option(arguments_, "run-id");
+    const runId = rawRunId === undefined ? undefined : Schema11.decodeUnknownSync(TaskRunId)(rawRunId);
+    if ((error !== undefined || question !== undefined) && (option(arguments_, "message") !== undefined || option(arguments_, "message-file") !== undefined || error !== undefined && question !== undefined)) {
+      throw new Error("Use one of --question, --error, or --message/--message-file");
+    }
+    const message = error === undefined && question === undefined ? await readInput(arguments_, "message") : undefined;
+    if (error === undefined && question === undefined && message === undefined) {
+      throw new Error("A bot reply requires --message, --message-file, --error, or --question");
+    }
+    const reply = question !== undefined ? { question: Schema11.decodeUnknownSync(RequestTaskInput.fields.question)(question) } : error === undefined ? { result: message ?? "" } : { error };
+    await writeBotReply(id, reply, runId);
     print({ submitted: true, task_id: id });
     return;
   }
@@ -6172,7 +7222,7 @@ var runCli = async (command, raw) => {
     const sandbox = option(arguments_, "sandbox");
     const model = option(arguments_, "model") ?? existing?.model;
     const gatewayInput = option(arguments_, "grok-gateway") ?? existing?.grokGateway;
-    const grokGateway = gatewayInput === undefined ? undefined : resolve3(gatewayInput);
+    const grokGateway = gatewayInput === undefined ? undefined : resolve4(gatewayInput);
     const providerInput = option(arguments_, "providers");
     const providers = providerInput === undefined ? existing?.providers : providerInput === "auto" ? undefined : parseProviders(providerInput);
     const configuration2 = StoredConfiguration.make({
@@ -6276,9 +7326,9 @@ var runCli = async (command, raw) => {
       ...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 ? [
+      ...(selectedProviders ?? (grokGateway === undefined ? [] : ["grok-bot"])).flatMap((provider) => provider === "grok-bot" ? grokBots === undefined ? [
         "Configured Grok Bot gateway is unavailable; check its discovery file and host process"
-      ] : [] : providerExecutables[provider] === "not found" ? [`Configured provider ${provider} is not installed or not on PATH`] : []) ?? []
+      ] : [] : providerExecutables[provider] === "not found" ? [`Configured provider ${provider} is not installed or not on PATH`] : [])
     ];
     print({
       version,
@@ -6354,6 +7404,31 @@ var runCli = async (command, raw) => {
     return;
   }
   const { configuration, relay } = await client();
+  if (command === "request-input") {
+    allowOptions(arguments_, ["question", "run-id"]);
+    const rawQuestion = option(arguments_, "question");
+    if (rawQuestion === undefined)
+      throw new Error("--question is required");
+    const question = Schema11.decodeUnknownSync(RequestTaskInput.fields.question)(rawQuestion);
+    const id = arguments_.positionals.length === 0 ? undefined : Schema11.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    const rawRunId = option(arguments_, "run-id");
+    const runId = rawRunId === undefined ? undefined : Schema11.decodeUnknownSync(TaskRunId)(rawRunId);
+    print(await Effect10.runPromise(requestInput(relay, configuration, question, id, runId)));
+    return;
+  }
+  if (command === "answer") {
+    allowOptions(arguments_, ["request-id", "message", "message-file"]);
+    const id = Schema11.decodeUnknownSync(TaskId)(identifier(arguments_, "task id"));
+    const requestId = option(arguments_, "request-id");
+    if (requestId === undefined)
+      throw new Error("--request-id is required; use the input request id from status or inbox");
+    const input = Schema11.decodeUnknownSync(AnswerTaskInput)({
+      requestId,
+      answer: await readInput(arguments_, "message")
+    });
+    print(taskResult(await Effect10.runPromise(relay.answerTaskInput(id, input))));
+    return;
+  }
   if (command === "progress") {
     allowOptions(arguments_, ["message"]);
     const rawId = arguments_.positionals.length === 0 ? configuration.mcpTaskId : identifier(arguments_, "task id");
@@ -6382,12 +7457,14 @@ var runCli = async (command, raw) => {
     allowOptions(arguments_, [
       "context",
       "context-file",
+      "deadline",
       "attach",
       "no-wait",
       "parent",
       "prompt",
       "prompt-file",
       "provider",
+      "request-id",
       "target",
       "thread",
       "timeout",
@@ -6417,15 +7494,19 @@ var runCli = async (command, raw) => {
     const workspace = option(arguments_, "workspace");
     const provider = option(arguments_, "provider");
     const parent = option(arguments_, "parent");
+    const deadline = option(arguments_, "deadline");
+    const requestId = option(arguments_, "request-id");
     const task = await Effect10.runPromise(createDelegation(relay, configuration, {
       prompt,
+      ...requestId === undefined ? {} : { requestId: Schema11.decodeUnknownSync(TaskRequestId)(requestId) },
       ...target === undefined ? {} : { target },
       ...context === undefined ? {} : { context },
       ...thread === undefined ? {} : { threadId: Schema11.decodeUnknownSync(ThreadId)(thread) },
       ...parent === undefined ? {} : { parentTaskId: Schema11.decodeUnknownSync(TaskId)(parent) },
       ...workspace === undefined ? {} : { workspace },
       ...provider === undefined ? {} : { provider: Schema11.decodeUnknownSync(Provider)(provider) },
-      ...attachments2.length === 0 ? {} : { attachments: attachments2 }
+      ...attachments2.length === 0 ? {} : { attachments: attachments2 },
+      ...deadline === undefined ? {} : { expiresAt: Schema11.decodeUnknownSync(TaskDeadline)(deadline) }
     }));
     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));
@@ -6471,7 +7552,7 @@ var runCli = async (command, raw) => {
     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 });
+    print({ task_id: id, name, path: resolve4(destination), bytes: data.length });
     return;
   }
   if (command === "trace") {
@@ -6487,8 +7568,7 @@ var runCli = async (command, raw) => {
   if (command === "wait") {
     allowOptions(arguments_, ["timeout"]);
     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_)))));
+    print(taskResult(await Effect10.runPromise(waitForTask(relay, id, timeout(arguments_)))));
     return;
   }
   if (command === "cancel") {
@@ -6510,9 +7590,9 @@ var runCli = async (command, raw) => {
 init_src();
 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 { open as open4, realpath as realpath4, stat as stat5 } from "node:fs/promises";
 import { arch, hostname as hostname3, platform as platform4 } from "node:os";
-import { basename as basename3, isAbsolute as isAbsolute3, relative as relative2 } from "node:path";
+import { basename as basename3, isAbsolute as isAbsolute4, relative as relative2 } from "node:path";
 import { WebSocket as WebSocket2 } from "ws";
 var maxQueuedRelayMessages = 8;
 
@@ -6545,6 +7625,8 @@ var capabilities = (providers) => {
   if (providers.some((provider) => provider !== "grok-bot")) {
     values2.push({ id: "task-attachments", label: "Task file attachments" });
   }
+  values2.push({ id: "task-clarification", label: "Task clarification and resume" });
+  values2.push({ id: "task-deadlines", label: "Task deadlines" });
   if (findExecutable("google-chrome") !== undefined || findExecutable("chromium") !== undefined || platform4() === "darwin") {
     values2.push({ id: "browser-session", label: "Signed-in browser" });
   }
@@ -6588,10 +7670,10 @@ var allowedWorkspace = async (configuration, requested) => {
   if (selected === undefined) {
     throw new Error("No workspace is configured on this device");
   }
-  const candidate = await realpath5(selected);
+  const candidate = await realpath4(selected);
   const allowed = configuration.workspaces.some((root) => {
     const child = relative2(root, candidate);
-    return child === "" || !child.startsWith("..") && !isAbsolute3(child);
+    return child === "" || !child.startsWith("..") && !isAbsolute4(child);
   });
   if (!allowed) {
     throw new Error(`Workspace ${candidate} is outside this device's configured workspace roots`);
@@ -6617,7 +7699,7 @@ var openAllowedWorkspace = async (configuration, requested) => {
         throw new Error(`Workspace ${path} changed before provider startup`);
       }
       if (operatingSystem2 !== "linux") {
-        const currentPath = await realpath5(path);
+        const currentPath = await realpath4(path);
         const currentPathIdentity = await stat5(currentPath);
         if (currentPathIdentity.dev !== identity.dev || currentPathIdentity.ino !== identity.ino) {
           throw new Error(`Workspace ${path} changed before provider startup`);
@@ -6627,7 +7709,7 @@ var openAllowedWorkspace = async (configuration, requested) => {
     close: () => handle.close()
   };
 };
-var promptFor = (task, deviceName, files) => {
+var promptFor = (task, deviceName, supportsClarification, files) => {
   const context = task.context === undefined ? "" : `
 
 Relevant context supplied by the sending agent:
@@ -6638,6 +7720,9 @@ ${task.context}`;
     "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.",
+    ...supportsClarification ? [
+      "If essential information is missing, run `cohall request-input --question 'Your question'` or the task_request_input MCP tool, then end this turn immediately. Cohall will pause the task and resume it when the sender answers. Do not guess, keep working, or report a final result after requesting input."
+    ] : [],
     ...files === undefined ? [] : [
       ...files.inputNames.length === 0 ? [] : [
         `Input directory: ${files.input}`,
@@ -6648,7 +7733,13 @@ ${task.context}`;
     ],
     `
 Task:
-${task.prompt}${context}`
+${task.prompt}${context}`,
+    ...(task.clarifications ?? []).flatMap((question) => question.answer === undefined ? [] : [
+      `Clarification question:
+${question.question}
+Sender's answer:
+${question.answer.text}`
+    ])
   ].join(`
 `);
 };
@@ -6657,6 +7748,7 @@ var send = (state, event) => {
     state.socket.send(JSON.stringify(event));
   }
 };
+var taskRunKey = (taskId, runId) => `${taskId}:${runId ?? ""}`;
 var omitOutputFiles = (event, note) => {
   if (event._tag !== "TaskFinished" || (event.attachments?.length ?? 0) === 0) {
     return event;
@@ -6664,16 +7756,17 @@ var omitOutputFiles = (event, note) => {
   const message = `
 
 [Output files omitted: ${note}]`;
-  return SocketEvent.make({
+  return SocketEvent.cases.TaskFinished.make({
     _tag: "TaskFinished",
     taskId: event.taskId,
+    ...event.runId === undefined ? {} : { runId: event.runId },
     result: `${event.result.slice(0, 131072 - message.length)}${message}`,
     ...event.providerSessionId === undefined ? {} : { providerSessionId: event.providerSessionId }
   });
 };
-var sendTerminal = (state, taskId, event) => {
+var sendTerminal = (state, event) => {
   const safeEvent = state.supportsAttachments ? event : omitOutputFiles(event, "the relay does not support attachments. Upgrade the relay and retry.");
-  state.terminal.set(taskId, safeEvent);
+  state.terminal.set(taskRunKey(event.taskId, event.runId), safeEvent);
   if (state.socket?.readyState === WebSocket2.OPEN) {
     state.socket.send(JSON.stringify(safeEvent));
   }
@@ -6685,12 +7778,12 @@ var sendOperationTerminal = (state, operationId, event) => {
     state.socket.send(payload);
   }
 };
-var remember = (state, taskId) => {
-  state.completed.add(taskId);
+var remember = (state, task) => {
+  state.completed.add(taskRunKey(task.id, task.runId));
   if (state.completed.size <= 1000) {
     return;
   }
-  const oldest = state.completed.values().next();
+  const oldest = state.completed.keys().next();
   if (!oldest.done) {
     state.completed.delete(oldest.value);
     state.terminal.delete(oldest.value);
@@ -6708,8 +7801,9 @@ var rememberOperation = (state, operationId) => {
   }
 };
 var sessionKey = (task) => `${task.threadId}:${task.provider}`;
+var hasCompletedRun = (state, task) => state.completed.has(taskRunKey(task.id, task.runId));
 var drain = (configuration, state) => {
-  if (state.operation !== undefined) {
+  if (state.stopping || state.operation !== undefined) {
     return;
   }
   if (state.tasks.size === 0) {
@@ -6732,16 +7826,37 @@ var drain = (configuration, state) => {
   }
 };
 var execute = (configuration, state, task) => {
-  if (state.tasks.has(task.id) || state.completed.has(task.id)) {
+  if (state.tasks.has(task.id) || hasCompletedRun(state, task)) {
     return;
   }
   const controller = new AbortController;
-  state.tasks.set(task.id, { task, controller });
-  send(state, SocketEvent.make({ _tag: "TaskAccepted", taskId: task.id }));
-  const workflow = Effect11.gen(function* () {
+  let deadlineTimer;
+  const enforceDeadline = () => {
+    if (task.expiresAt === undefined)
+      return;
+    const remaining = Date.parse(task.expiresAt) - Date.now();
+    if (remaining <= 0) {
+      controller.abort();
+      return;
+    }
+    deadlineTimer = setTimeout(enforceDeadline, Math.min(remaining, 2147483647));
+  };
+  enforceDeadline();
+  send(state, SocketEvent.make({
+    _tag: "TaskAccepted",
+    taskId: task.id,
+    ...task.runId === undefined ? {} : { runId: task.runId }
+  }));
+  const workflow = Effect11.scoped(Effect11.gen(function* () {
+    if (configuration.providers !== undefined && !configuration.providers.includes(task.provider)) {
+      return yield* new ProviderRunError({
+        provider: task.provider,
+        message: `${task.provider} is not enabled on this device. Update its configured providers and restart the worker before retrying.`
+      });
+    }
     if (task.provider === "grok-bot") {
       return yield* Effect11.tryPromise({
-        try: (signal) => runGrokBot(configuration.grokGateway, task, signal),
+        try: (signal) => runGrokBot(configuration.grokGateway, task, signal, state.supportsClarification),
         catch: (cause) => new ProviderRunError({
           provider: task.provider,
           message: cause instanceof Error ? cause.message : String(cause)
@@ -6755,68 +7870,84 @@ var execute = (configuration, state, task) => {
         message: "The relay does not support task file attachments"
       });
     }
-    const workspace = yield* Effect11.tryPromise({
+    const workspace = yield* Effect11.acquireRelease(Effect11.tryPromise({
       try: () => openAllowedWorkspace(configuration, task.workspace),
       catch: (cause) => new ProviderRunError({
         provider,
         message: cause instanceof Error ? cause.message : String(cause)
       })
-    });
-    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(() => {
+    }), (workspace2) => Effect11.promise(() => workspace2.close().catch(() => {
       return;
-    }))));
-  });
-  Effect11.runPromise(workflow, { signal: controller.signal }).then((result) => {
-    const finished = SocketEvent.make({
-      _tag: "TaskFinished",
+    })));
+    const files = state.supportsAttachments ? yield* prepareTaskFiles(configuration, task.id, task.inputAttachmentNames ?? []).pipe(Effect11.mapError((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,
-      result: result.result,
-      ...result.sessionId === undefined ? {} : { providerSessionId: result.sessionId },
-      ...result.attachments === undefined || result.attachments.length === 0 ? {} : { attachments: result.attachments }
-    });
+      prompt: promptFor(task, configuration.name, state.supportsClarification, files),
+      cwd: workspace.cwd,
+      beforeSpawn: workspace.validate,
+      ...sessionId === undefined ? {} : { sessionId },
+      ...task.runId === undefined ? {} : { runId: task.runId },
+      ...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)
+      })
+    }).pipe(Effect11.uninterruptible)));
+  }));
+  const done = Effect11.runPromise(workflow, { signal: controller.signal }).then((result) => {
+    let finished;
+    if (result.question !== undefined) {
+      if (!state.supportsClarification || task.runId === undefined)
+        throw new Error("Upgrade the relay before requesting clarification");
+      finished = SocketEvent.cases.TaskInputRequested.make({
+        _tag: "TaskInputRequested",
+        taskId: task.id,
+        runId: task.runId,
+        question: result.question
+      });
+    } else {
+      finished = SocketEvent.cases.TaskFinished.make({
+        _tag: "TaskFinished",
+        taskId: task.id,
+        ...task.runId === undefined ? {} : { runId: task.runId },
+        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, bounded2);
+    remember(state, task);
+    sendTerminal(state, bounded2);
   }).catch((cause) => {
-    remember(state, task.id);
-    sendTerminal(state, task.id, controller.signal.aborted ? SocketEvent.make({ _tag: "TaskCancelled", taskId: task.id }) : SocketEvent.make({
+    remember(state, task);
+    sendTerminal(state, controller.signal.aborted ? SocketEvent.cases.TaskCancelled.make({
+      _tag: "TaskCancelled",
+      taskId: task.id,
+      ...task.runId === undefined ? {} : { runId: task.runId }
+    }) : SocketEvent.cases.TaskFailed.make({
       _tag: "TaskFailed",
       taskId: task.id,
+      ...task.runId === undefined ? {} : { runId: task.runId },
       error: (cause instanceof Error ? cause.message : String(cause)).slice(0, 16384)
     }));
   }).finally(() => {
+    clearTimeout(deadlineTimer);
     state.tasks.delete(task.id);
     drain(configuration, state);
   });
+  state.tasks.set(task.id, { task, controller, done });
 };
 var executeOperation = (configuration, state, operation) => {
   if (state.operation !== undefined || state.completedOperations.has(operation.id)) {
@@ -6844,6 +7975,8 @@ var executeOperation = (configuration, state, operation) => {
   });
 };
 var scheduleOperation = (configuration, state, operation) => {
+  if (state.stopping)
+    return;
   if (state.completedOperations.has(operation.id) || state.operation?.id === operation.id || state.operationQueue.some((pending) => pending.id === operation.id)) {
     return;
   }
@@ -6865,7 +7998,18 @@ var performDeviceOperation = (operation, currentVersion, runUpgrade = upgrade) =
   delegated: true
 }).then((result) => JSON.stringify(result));
 var schedule = (configuration, state, task) => {
-  if (state.tasks.has(task.id) || state.completed.has(task.id) || state.queue.some((queued) => queued.id === task.id)) {
+  if (state.stopping)
+    return;
+  if (hasCompletedRun(state, task) || state.queue.some((queued) => queued.id === task.id && queued.runId === task.runId)) {
+    return;
+  }
+  const running = state.tasks.get(task.id);
+  if (running !== undefined && running.task.runId === task.runId) {
+    send(state, SocketEvent.make({
+      _tag: "TaskAccepted",
+      taskId: task.id,
+      ...task.runId === undefined ? {} : { runId: task.runId }
+    }));
     return;
   }
   if (task.providerSessionId !== undefined) {
@@ -6881,20 +8025,24 @@ var schedule = (configuration, state, task) => {
   }
   execute(configuration, state, task);
 };
-var cancel = (state, taskId) => {
+var cancel = (state, taskId, runId) => {
   const running = state.tasks.get(taskId);
-  if (running !== undefined) {
+  if (running !== undefined && (runId === undefined || running.task.runId === runId)) {
     if (running.task.provider !== "grok-bot") {
       running.controller.abort();
     }
     return;
   }
-  const index = state.queue.findIndex((task) => task.id === taskId);
+  const index = state.queue.findIndex((task) => task.id === taskId && (runId === undefined || task.runId === runId));
   if (index !== -1) {
     state.queue.splice(index, 1);
   }
-  remember(state, taskId);
-  sendTerminal(state, taskId, SocketEvent.make({ _tag: "TaskCancelled", taskId }));
+  remember(state, { id: taskId, ...runId === undefined ? {} : { runId } });
+  sendTerminal(state, SocketEvent.cases.TaskCancelled.make({
+    _tag: "TaskCancelled",
+    taskId,
+    ...runId === undefined ? {} : { runId }
+  }));
 };
 var connect = (configuration, state) => Effect11.tryPromise({
   try: (signal) => new Promise((complete) => {
@@ -6903,6 +8051,15 @@ var connect = (configuration, state) => Effect11.tryPromise({
       perMessageDeflate: false,
       allowSynchronousEvents: false
     });
+    let closed = false;
+    let connectionDeadline = setTimeout(() => socket.terminate(), 1e4);
+    const resetConnectionDeadline = () => {
+      if (closed || state.socket !== socket)
+        return;
+      clearTimeout(connectionDeadline);
+      connectionDeadline = setTimeout(() => socket.terminate(), 45000);
+    };
+    socket.on("ping", resetConnectionDeadline);
     let bots = [];
     let refreshing = false;
     const refreshBots = async () => {
@@ -6930,13 +8087,13 @@ var connect = (configuration, state) => Effect11.tryPromise({
       }));
       refreshBots();
     }, 15000);
-    let closed = false;
     let queuedMessages = 0;
     const close = () => {
       if (closed) {
         return;
       }
       closed = true;
+      clearTimeout(connectionDeadline);
       clearInterval(heartbeat);
       if (state.socket === socket) {
         state.socket = undefined;
@@ -6944,7 +8101,7 @@ var connect = (configuration, state) => Effect11.tryPromise({
       complete();
     };
     signal.addEventListener("abort", () => {
-      socket.close();
+      socket.terminate();
       close();
     }, { once: true });
     socket.once("open", () => {
@@ -6967,14 +8124,16 @@ var connect = (configuration, state) => Effect11.tryPromise({
         }).pipe(Effect11.flatMap(decodeSocketEvent)));
         if (event._tag === "Connected") {
           state.supportsAttachments = event.taskAttachments === true;
+          state.supportsClarification = event.taskClarification === true;
           state.socket = socket;
+          resetConnectionDeadline();
           socket.send(JSON.stringify(SocketEvent.make({
             _tag: "DeviceHello",
             device: describeDevice(configuration, state.tasks.size > 0 || state.operation !== undefined ? "busy" : "online", bots)
           })));
-          for (const [taskId, pending] of state.terminal) {
+          for (const [key, 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);
+            state.terminal.set(key, safeEvent);
             socket.send(JSON.stringify(safeEvent));
           }
           for (const payload of state.operationTerminal.values()) {
@@ -6988,12 +8147,12 @@ var connect = (configuration, state) => Effect11.tryPromise({
           return;
         }
         if (event._tag === "CancelTask") {
-          cancel(state, event.taskId);
+          cancel(state, event.taskId, event.runId);
           return;
         }
         if (event._tag === "TaskSettled") {
-          state.terminal.delete(event.taskId);
-          cleanupBotReply(event.taskId).catch(() => {
+          state.terminal.delete(taskRunKey(event.taskId, event.runId));
+          cleanupBotReply(event.taskId, event.runId).catch(() => {
             console.error(`Could not remove local bot reply for settled task ${event.taskId}`);
           });
           return;
@@ -7025,7 +8184,9 @@ var connect = (configuration, state) => Effect11.tryPromise({
 var runDaemon = (configuration) => {
   const state = {
     socket: undefined,
+    stopping: false,
     supportsAttachments: false,
+    supportsClarification: false,
     processing: Promise.resolve(),
     terminal: new Map,
     queue: [],
@@ -7037,11 +8198,14 @@ var runDaemon = (configuration) => {
     operationTerminal: new Map,
     completedOperations: new Set
   };
-  return connect(configuration, state).pipe(Effect11.repeat({ schedule: Schedule3.spaced("2 seconds") }), Effect11.ensuring(Effect11.sync(() => {
+  return connect(configuration, state).pipe(Effect11.repeat({ schedule: Schedule3.spaced("2 seconds") }), Effect11.ensuring(Effect11.promise(async () => {
+    state.stopping = true;
     state.socket?.close();
-    for (const { controller } of state.tasks.values()) {
+    const running = [...state.tasks.values()];
+    for (const { controller } of running) {
       controller.abort();
     }
+    await Promise.allSettled(running.map(({ done }) => done));
   })));
 };
 
@@ -7113,6 +8277,24 @@ var runMcp = async (configuration) => {
     token: configuration.token
   });
   const server = new McpServer({ name: "cohall", version });
+  server.registerTool("task_request_input", {
+    title: "Ask for task clarification",
+    description: "Ask the original sender for essential missing information. After this succeeds, end the current worker turn immediately. Cohall pauses when the turn exits and resumes the same task after an answer. Inherits the delegated task and turn when omitted.",
+    inputSchema: {
+      task_id: z.string().uuid().optional(),
+      run_id: z.string().uuid().optional(),
+      question: z.string().min(1).max(maxClarificationBytes)
+    }
+  }, async ({ task_id, run_id, question }) => output(await Effect12.runPromise(requestInput(client2, configuration, Schema13.decodeUnknownSync(RequestTaskInput.fields.question)(question), task_id === undefined ? undefined : Schema13.decodeUnknownSync(TaskId)(task_id), run_id === undefined ? undefined : Schema13.decodeUnknownSync(TaskRunId)(run_id)))));
+  server.registerTool("task_answer", {
+    title: "Answer a worker's question",
+    description: "Answer the current clarification and resume the same task. Use input_request.id from task_status or delegate as request_id, or inputRequest.id from completion_inbox. Only the original requester or relay owner can answer. Use wait_task to collect the resumed result.",
+    inputSchema: {
+      task_id: z.string().uuid(),
+      request_id: z.string().uuid(),
+      answer: z.string().min(1).max(maxClarificationBytes)
+    }
+  }, async ({ task_id, request_id, answer }) => output(taskResult(await Effect12.runPromise(client2.answerTaskInput(Schema13.decodeUnknownSync(TaskId)(task_id), Schema13.decodeUnknownSync(AnswerTaskInput)({ requestId: request_id, answer }))))));
   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.`,
@@ -7142,6 +8324,7 @@ var runMcp = async (configuration) => {
     description: "Send focused work to a Cohall device or named Grok Bot. When the request depends on the current conversation, distill its motivation, relevant facts, prior findings, constraints, and desired decision into context; Cohall cannot read the host transcript. Never forward unrelated transcript content. Reuse thread_id for related follow-ups. Grok Bots use their existing conversation; a Cohall thread does not isolate it.",
     inputSchema: {
       prompt: z.string().min(1).max(131072),
+      request_id: z.string().uuid().optional().describe("A UUID v4 generated before submitting. Reuse with identical input and the same client credential after a lost response to recover the original task. Use stable device IDs or device/bot IDs for retries. For thread follow-ups, select a target or provider explicitly; select Bots explicitly."),
       target: z.string().optional().describe("Device name, hostname or ID; @BotName; or @device/BotName. Use list_bots targets to disambiguate."),
       provider: z.enum(Provider.literals).optional().describe("Inferred as grok-bot for a bot target; otherwise defaults to codex."),
       context: z.string().max(131072).optional().describe("Distilled context the target needs: why the user is asking, relevant facts and prior findings, constraints, and the intended decision. The calling agent must supply this when the prompt depends on its conversation; omit it only for a self-contained task."),
@@ -7150,10 +8333,12 @@ var runMcp = async (configuration) => {
       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)
+      timeout_seconds: z.number().int().min(5).max(86400).default(900),
+      deadline: z.string().optional().describe("Absolute ISO-8601 UTC deadline for coding work, preserved through clarification. Overdue work stops; timeout_seconds only limits waiting.")
     }
   }, async ({
     prompt,
+    request_id,
     target,
     provider,
     context,
@@ -7162,25 +8347,28 @@ var runMcp = async (configuration) => {
     workspace,
     attachment_paths,
     wait,
-    timeout_seconds
-  }) => {
+    timeout_seconds,
+    deadline
+  }, { signal }) => {
     const attachments2 = await readInputAttachments(attachment_paths ?? []);
     const task = await Effect12.runPromise(createDelegation(client2, configuration, {
       prompt,
+      ...request_id === undefined ? {} : { requestId: Schema13.decodeUnknownSync(TaskRequestId)(request_id) },
       ...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 },
-      ...attachments2.length === 0 ? {} : { attachments: attachments2 }
-    }));
-    const completed = wait ? await Effect12.runPromise(waitForTask(client2, task, timeout_seconds)) : task;
-    return output(wait ? await acknowledgedTaskResult(client2, completed) : taskResult(completed));
+      ...attachments2.length === 0 ? {} : { attachments: attachments2 },
+      ...deadline === undefined ? {} : { expiresAt: Schema13.decodeUnknownSync(TaskDeadline)(deadline) }
+    }), { signal });
+    const completed = wait ? await Effect12.runPromise(waitForTask(client2, task, timeout_seconds), { signal }) : task;
+    return output(wait ? await acknowledgedTaskResult(client2, completed, signal) : 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.",
+    title: "List pending questions and completed work",
+    description: "List up to 20 unanswered clarification requests and unacknowledged completed tasks sent by this client. hasMore signals additional entries. Answer questions with task_answer; use task_status for full results and acknowledge only handled completions.",
     inputSchema: {}
   }, async () => output(await Effect12.runPromise(client2.inbox())));
   server.registerTool("acknowledge_completion", {
@@ -7221,18 +8409,19 @@ var runMcp = async (configuration) => {
   }, 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.",
+    description: "Wait for a Cohall task to finish or need input. Answer a needs_input result with task_answer, then wait again.",
     inputSchema: {
       task_id: z.string().uuid(),
       timeout_seconds: z.number().int().min(5).max(86400).default(900)
     }
-  }, async ({ task_id, timeout_seconds }) => {
-    const task = await Effect12.runPromise(client2.getTask(TaskId.make(task_id)));
-    return output(taskResult(await Effect12.runPromise(waitForTask(client2, task, timeout_seconds))));
+  }, async ({ task_id, timeout_seconds }, { signal }) => {
+    return output(taskResult(await Effect12.runPromise(waitForTask(client2, TaskId.make(task_id), timeout_seconds), {
+      signal
+    })));
   });
   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.",
+    description: "Cancel coding work, a paused task, or a Bot task that has never been dispatched. Active Grok Bot tasks must be stopped in Grok Bot.",
     inputSchema: { task_id: z.string().uuid() }
   }, async ({ task_id }) => output(taskResult(await Effect12.runPromise(client2.cancelTask(TaskId.make(task_id))))));
   server.registerTool("thread_context", {
@@ -7269,7 +8458,19 @@ var main = async () => {
   }
   if (command === "device") {
     const configuration = await Effect16.runPromise(loadDeviceConfiguration);
-    await Effect16.runPromise(runDaemon(configuration));
+    const controller = new AbortController;
+    const stop = () => controller.abort();
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    try {
+      await Effect16.runPromise(runDaemon(configuration), { signal: controller.signal }).catch((cause) => {
+        if (!controller.signal.aborted)
+          throw cause;
+      });
+    } finally {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    }
     return;
   }
   if (command === "mcp") {
@@ -7284,4 +8485,4 @@ await main().catch((cause) => {
   process.exitCode = 1;
 });
 
-//# debugId=48BD90839B9C2B1564756E2164756E21
+//# debugId=4195FFD0F10A67E564756E2164756E21