@questionbase/deskfree 0.3.0-alpha.21 → 0.3.0-alpha.23

package/dist/index.js

@@ -3857,19 +3857,19 @@ var DeskFreeClient = class {
     return this.request("POST", "messages.update", input);
   }
   /**
-   * Send a text message (with optional attachments or suggestions) to a DeskFree conversation.
+   * Send a streaming chunk (delta only) for an in-progress message.
+   * Broadcasts delta over WS and stores full content in DynamoDB for crash recovery.
+   */
+  async streamChunk(input) {
+    return this.request("POST", "messages.streamChunk", input);
+  }
+  /**
+   * Send a text message to a DeskFree conversation.
    *
-   * @param input - Message content, optional userId, taskId, attachments, and suggestions
+   * @param input - Message content, optional userId, taskId, attachments
    */
   async sendMessage(input) {
-    if (!input.content && !input.suggestions) {
-      throw new DeskFreeError(
-        "client",
-        "content",
-        "content or suggestions is required",
-        "Missing required parameter: provide content or suggestions."
-      );
-    }
+    this.requireNonEmpty(input.content, "content");
     return this.request("POST", "messages.send", input);
   }
   /** Fetch paginated message history for a conversation. */
@@ -3894,11 +3894,25 @@ var DeskFreeClient = class {
     this.requireNonEmpty(input.taskId, "taskId");
     return this.request("POST", "tasks.claim", input);
   }
-  /** Update the deliverable (markdown or HTML content) for a task. */
-  async updateDeliverable(input) {
+  /** Fetch a lightweight task summary by ID. Read-only, no side effects. */
+  async getTask(input) {
     this.requireNonEmpty(input.taskId, "taskId");
-    this.requireNonEmpty(input.deliverable, "deliverable");
-    return this.request("POST", "tasks.updateDeliverable", input);
+    return this.request("GET", "tasks.get", input);
+  }
+  /** Update the content of an existing file. */
+  async updateFile(input) {
+    this.requireNonEmpty(input.fileId, "fileId");
+    this.requireNonEmpty(input.content, "content");
+    return this.request("POST", "files.update", input);
+  }
+  /** Create a new persistent file. */
+  async createFile(input) {
+    this.requireNonEmpty(input.name, "name");
+    return this.request("POST", "files.create", input);
+  }
+  /** List all files for this bot (metadata only, no content). */
+  async listFiles() {
+    return this.request("GET", "files.list", {});
   }
   /** Send an agent status update to DeskFree. */
   async statusUpdate(input) {
@@ -3923,32 +3937,22 @@ var DeskFreeClient = class {
     this.requireNonEmpty(input.taskId, "taskId");
     return this.request("POST", "tasks.complete", input);
   }
-  /** Suggest new tasks for the human to review and approve (via messages.send with suggestions). */
-  async suggestTasks(input) {
+  /** Reopen a completed/human task back to bot status for further work. */
+  async reopenTask(input) {
+    this.requireNonEmpty(input.taskId, "taskId");
+    return this.request("POST", "tasks.reopen", input);
+  }
+  /** Propose a plan — creates a proposal message with plan metadata. No DB rows until human approves. */
+  async proposePlan(input) {
     if (!input.tasks || input.tasks.length === 0) {
       throw new DeskFreeError(
         "client",
         "tasks",
         "tasks array is required and cannot be empty",
-        "Missing required parameter: tasks. Please provide at least one task to suggest."
+        "Missing required parameter: tasks."
       );
     }
-    return this.sendMessage({
-      suggestions: input.tasks,
-      taskId: input.taskId
-    });
-  }
-  /** Suggest tasks via the dedicated bot/tasks.suggest endpoint. */
-  async suggestTasksDedicated(input) {
-    if (!input.suggestions || input.suggestions.length === 0) {
-      throw new DeskFreeError(
-        "client",
-        "suggestions",
-        "suggestions array is required and cannot be empty",
-        "Missing required parameter: suggestions."
-      );
-    }
-    return this.request("POST", "tasks.suggest", input);
+    return this.request("POST", "tasks.propose", input);
   }
   /**
    * Claim a pending evaluation for a task. Atomically sets isWorking=true where
@@ -4121,6 +4125,8 @@ function resolvePluginStorePath(subpath) {
 
 // src/streaming.ts
 var THROTTLE_MS = 300;
+var CHAR_BUFFER_SIZE = 256;
+var CLOSE_MAX_RETRIES = 3;
 var DeskFreeStreamingSession = class {
   client;
   log;
@@ -4128,9 +4134,11 @@ var DeskFreeStreamingSession = class {
   currentText = "";
   closed = false;
   lastUpdateTime = 0;
-  pendingText = null;
+  pendingDelta = "";
   pendingTimer = null;
   queue = Promise.resolve();
+  /** Full accumulated text (currentText + pendingDelta) */
+  fullText = "";
   constructor(client, log) {
     this.client = client;
     this.log = log;
@@ -4146,51 +4154,72 @@ var DeskFreeStreamingSession = class {
     const result = await this.client.sendMessage({ content, taskId });
     this.messageId = result.messageId;
     this.currentText = content;
+    this.fullText = content;
     this.lastUpdateTime = Date.now();
     this.log.info(`Streaming started: messageId=${this.messageId}`);
     return this.messageId;
   }
   /**
-   * Update the message with new content. Throttled to THROTTLE_MS.
-   * Content should be the FULL message text (not a delta).
+   * Push new text (appended to the stream). Buffers and flushes as delta.
+   * Content should be the FULL accumulated message text.
    */
   async update(fullText) {
     if (!this.messageId || this.closed) return;
-    if (fullText === this.currentText) return;
+    if (fullText === this.fullText) return;
+    const delta = fullText.slice(this.fullText.length);
+    if (!delta) return;
+    this.fullText = fullText;
+    this.pendingDelta += delta;
     const now = Date.now();
     const elapsed = now - this.lastUpdateTime;
-    if (elapsed >= THROTTLE_MS) {
-      await this.sendUpdate(fullText, true);
-    } else {
-      this.pendingText = fullText;
-      if (!this.pendingTimer) {
-        this.pendingTimer = setTimeout(async () => {
-          this.pendingTimer = null;
-          if (this.pendingText && !this.closed) {
-            const text = this.pendingText;
-            this.pendingText = null;
-            await this.sendUpdate(text, true);
-          }
-        }, THROTTLE_MS - elapsed);
-      }
+    const bufferFull = this.pendingDelta.length >= CHAR_BUFFER_SIZE;
+    const throttleExpired = elapsed >= THROTTLE_MS;
+    if (bufferFull || throttleExpired) {
+      this.flush();
+    } else if (!this.pendingTimer) {
+      this.pendingTimer = setTimeout(() => {
+        this.pendingTimer = null;
+        this.flush();
+      }, THROTTLE_MS - elapsed);
     }
   }
   /**
    * Finalize the streaming session with the final content.
+   * Retries up to 3 times with exponential backoff.
    */
   async close(finalText) {
     if (this.closed) return;
-    this.closed = true;
     if (this.pendingTimer) {
       clearTimeout(this.pendingTimer);
       this.pendingTimer = null;
     }
+    this.flush();
+    this.closed = true;
     await this.queue;
-    const text = finalText ?? this.pendingText ?? this.currentText;
-    if (this.messageId && text !== this.currentText) {
-      await this.sendUpdate(text, false);
-    } else if (this.messageId) {
-      await this.sendUpdate(this.currentText, false);
+    const text = finalText ?? (this.fullText || this.currentText);
+    if (this.messageId) {
+      for (let attempt = 0; attempt < CLOSE_MAX_RETRIES; attempt++) {
+        try {
+          await this.client.updateMessage({
+            messageId: this.messageId,
+            content: text,
+            streaming: false
+          });
+          break;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (attempt < CLOSE_MAX_RETRIES - 1) {
+            this.log.warn(
+              `Streaming close attempt ${attempt + 1} failed: ${msg}, retrying...`
+            );
+            await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+          } else {
+            this.log.error(
+              `Streaming close failed after ${CLOSE_MAX_RETRIES} attempts: ${msg}. Recovery worker will finalize.`
+            );
+          }
+        }
+      }
     }
     this.log.info(`Streaming closed: messageId=${this.messageId}`);
   }
@@ -4200,23 +4229,32 @@ var DeskFreeStreamingSession = class {
   getMessageId() {
     return this.messageId;
   }
-  async sendUpdate(content, streaming) {
-    if (!this.messageId) return;
+  /**
+   * Flush the pending delta buffer via streamChunk.
+   */
+  flush() {
+    if (this.pendingTimer) {
+      clearTimeout(this.pendingTimer);
+      this.pendingTimer = null;
+    }
+    const delta = this.pendingDelta;
+    if (!delta || !this.messageId || this.closed) return;
+    this.pendingDelta = "";
+    const fullContent = this.fullText;
     this.queue = this.queue.then(async () => {
       try {
-        await this.client.updateMessage({
+        await this.client.streamChunk({
           messageId: this.messageId,
-          content,
-          streaming
+          delta,
+          fullContent
         });
-        this.currentText = content;
+        this.currentText = fullContent;
         this.lastUpdateTime = Date.now();
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        this.log.warn(`Streaming update failed: ${msg}`);
+        this.log.warn(`Streaming delta failed: ${msg}`);
       }
     });
-    await this.queue;
   }
 };
 
@@ -4429,6 +4467,38 @@ async function fetchAndSaveMedia(attachment) {
     }
   }
 }
+var MAX_INSTRUCTIONS_LENGTH = 500;
+var MAX_CONTEXT_MESSAGES = 5;
+function truncateAtWord(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  const truncated = text.slice(0, maxLen);
+  const lastSpace = truncated.lastIndexOf(" ");
+  return (lastSpace > 0 ? truncated.slice(0, lastSpace) : truncated) + "\u2026";
+}
+function buildBodyForAgent(task, content, recentMessages) {
+  let prefix = `[Task thread: "${task.title}" | status: ${task.status} | isWorking: ${task.isWorking}]`;
+  if (task.instructions) {
+    prefix += "\n" + truncateAtWord(task.instructions, MAX_INSTRUCTIONS_LENGTH);
+  }
+  if (recentMessages && recentMessages.length > 0) {
+    prefix += "\n\nRecent thread messages:";
+    for (const msg of recentMessages) {
+      const author = msg.authorType === "bot" ? "\u{1F916} Bot" : msg.userName ?? "Human";
+      prefix += `
+- ${author}: ${truncateAtWord(msg.content, 200)}`;
+    }
+  }
+  return prefix + "\n\n" + content;
+}
+function resolveTaskRouting(task, hasAttachments) {
+  if (task.isWorking) {
+    return { target: "runner" };
+  }
+  if (hasAttachments && (task.status === "human" || task.status === "done")) {
+    return { target: "auto-reopen" };
+  }
+  return { target: "orchestrator" };
+}
 async function deliverMessageToAgent(ctx, message, client) {
   const runtime = getDeskFreeRuntime();
   const log = ctx.log ?? runtime.logging.createLogger("deskfree:deliver");
@@ -4471,9 +4541,55 @@ async function deliverMessageToAgent(ctx, message, client) {
       );
     }
   }
+  let bodyForAgent;
+  let routingTarget = "orchestrator";
+  if (message.taskId) {
+    try {
+      const task = await client.getTask({ taskId: message.taskId });
+      const routing = resolveTaskRouting(task, mediaPaths.length > 0);
+      routingTarget = routing.target;
+      if (routingTarget === "auto-reopen") {
+        log.info(
+          `Auto-reopening task ${message.taskId} (attachment on ${task.status} task)`
+        );
+        try {
+          await client.reopenTask({
+            taskId: message.taskId,
+            reason: "Human sent an attachment \u2014 reopening for further work"
+          });
+        } catch (reopenErr) {
+          const reopenMsg = reopenErr instanceof Error ? reopenErr.message : String(reopenErr);
+          log.warn(
+            `Failed to auto-reopen task ${message.taskId}: ${reopenMsg}`
+          );
+          routingTarget = "orchestrator";
+        }
+      }
+      let recentMessages;
+      try {
+        const msgList = await client.listMessages({
+          taskId: message.taskId,
+          limit: MAX_CONTEXT_MESSAGES
+        });
+        recentMessages = msgList.items.map((m) => ({
+          authorType: m.humanId ? "user" : "bot",
+          content: m.content,
+          userName: m.userName
+        }));
+      } catch {
+      }
+      bodyForAgent = buildBodyForAgent(task, message.content, recentMessages);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log.warn(`Failed to fetch task context for ${message.taskId}: ${errMsg}`);
+    }
+  }
+  const sessionKey = routingTarget === "runner" && message.taskId ? `agent:main:deskfree:task:${message.taskId}` : `agent:main:deskfree:dm:${peerId}`;
+  log.info(`Routing message to ${routingTarget} (session: ${sessionKey})`);
   const msgCtx = runtime.channel.reply.finalizeInboundContext({
     Body: message.content,
     RawBody: message.content,
+    ...bodyForAgent ? { BodyForAgent: bodyForAgent } : {},
     ChatType: "dm",
     Provider: "deskfree",
     Surface: "deskfree",
@@ -4485,7 +4601,7 @@ async function deliverMessageToAgent(ctx, message, client) {
     Timestamp: message.createdAt,
     AccountId: ctx.accountId,
     FromName: message.userName ?? "Unknown",
-    SessionKey: `agent:main:deskfree:dm:${peerId}`,
+    SessionKey: sessionKey,
     // Backward-compatible: first attachment
     MediaPath: mediaPaths[0],
     MediaType: mediaTypes[0],
@@ -4496,10 +4612,10 @@ async function deliverMessageToAgent(ctx, message, client) {
     MediaUrls: mediaUrls,
     MediaCount: mediaPaths.length
   });
+  let streamingSession = null;
+  let accumulatedText = "";
   try {
     const cfg = runtime.config.loadConfig();
-    let streamingSession = null;
-    let accumulatedText = "";
     const { dispatcher, replyOptions } = runtime.channel.reply.createReplyDispatcherWithTyping({
       channel: "deskfree",
       accountId: ctx.accountId,
@@ -4553,6 +4669,14 @@ async function deliverMessageToAgent(ctx, message, client) {
     });
     log.info(`Message ${message.messageId} dispatched successfully.`);
   } catch (err) {
+    const session = streamingSession;
+    if (session?.isActive()) {
+      try {
+        await session.close(accumulatedText || void 0);
+      } catch {
+      }
+      streamingSession = null;
+    }
     const errMsg = err instanceof Error ? err.message : String(err);
     log.warn(`Failed to dispatch message ${message.messageId}: ${errMsg}`);
     reportError("error", `Failed to dispatch message: ${errMsg}`, {
@@ -4585,22 +4709,21 @@ var wrapper_default = import_websocket.default;
 // src/gateway.ts
 var activeTaskId = null;
 var completedTaskId = null;
-function setActiveTaskId(taskId) {
-  if (taskId === null && activeTaskId !== null) {
-    completedTaskId = activeTaskId;
-  }
-  activeTaskId = taskId;
-}
+var inboundThreadId = null;
 function getActiveTaskId() {
-  return activeTaskId ?? completedTaskId;
+  return activeTaskId ?? completedTaskId ?? inboundThreadId;
 }
 function clearCompletedTaskId() {
   completedTaskId = null;
 }
+function setInboundThreadId(taskId) {
+  inboundThreadId = taskId;
+}
 var PING_INTERVAL_MS = 5 * 60 * 1e3;
 var POLL_FALLBACK_INTERVAL_MS = 30 * 1e3;
 var WS_CONNECTION_TIMEOUT_MS = 30 * 1e3;
 var WS_PONG_TIMEOUT_MS = 10 * 1e3;
+var NOTIFY_DEBOUNCE_MS = 200;
 var BACKOFF_INITIAL_MS = 2e3;
 var BACKOFF_MAX_MS = 3e4;
 var BACKOFF_FACTOR = 1.8;
@@ -4824,6 +4947,7 @@ async function runWebSocketConnection(opts) {
     let pingInterval;
     let connectionTimer;
     let pongTimer;
+    let notifyDebounceTimer;
     let isConnected = false;
     const cleanup = () => {
       if (pingInterval !== void 0) {
@@ -4838,6 +4962,10 @@ async function runWebSocketConnection(opts) {
         clearTimeout(pongTimer);
         pongTimer = void 0;
       }
+      if (notifyDebounceTimer !== void 0) {
+        clearTimeout(notifyDebounceTimer);
+        notifyDebounceTimer = void 0;
+      }
     };
     connectionTimer = setTimeout(() => {
       if (!isConnected) {
@@ -4918,15 +5046,21 @@ async function runWebSocketConnection(opts) {
           return;
         }
         if (msg.action === "notify") {
-          enqueuePoll(
-            client,
-            ctx,
-            () => cursor,
-            (c) => {
-              cursor = c ?? cursor;
-            },
-            log
-          );
+          if (notifyDebounceTimer !== void 0) {
+            clearTimeout(notifyDebounceTimer);
+          }
+          notifyDebounceTimer = setTimeout(() => {
+            notifyDebounceTimer = void 0;
+            enqueuePoll(
+              client,
+              ctx,
+              () => cursor,
+              (c) => {
+                cursor = c ?? cursor;
+              },
+              log
+            );
+          }, NOTIFY_DEBOUNCE_MS);
         } else if (msg.action === "pong") {
           if (pongTimer !== void 0) {
             clearTimeout(pongTimer);
@@ -5123,6 +5257,7 @@ async function pollAndDeliver(client, ctx, cursor, log, account) {
         continue;
       }
       clearCompletedTaskId();
+      setInboundThreadId(message.taskId ?? null);
       await deliverMessageToAgent(ctx, message, client);
       deliveredMessageIds.add(message.messageId);
       deliveredCount++;
@@ -7765,76 +7900,67 @@ var ORCHESTRATOR_TOOLS = {
     description: "Get full workspace state \u2014 all tasks, recently done tasks, active initiatives. Use to assess what needs attention.",
     parameters: Type.Object({})
   },
-  START_TASK: {
-    name: "deskfree_start_task",
-    description: "Claim a bot task (isWorking=false) and start working. Returns full context (instructions, deliverable, message history).",
+  REOPEN_TASK: {
+    name: "deskfree_reopen_task",
+    description: "Reopen a completed or human-side task back to bot status. Use when a human message in a task thread indicates more work is needed. The task becomes available for a worker to claim.",
     parameters: Type.Object({
-      taskId: Type.String({ description: "Task UUID to claim" })
-    })
-  },
-  UPDATE_DELIVERABLE: {
-    name: "deskfree_update_deliverable",
-    description: 'Update task deliverable. Build incrementally as you work. Use format="html" when delivering rich web content (reports, dashboards, interactive pages); use format="markdown" (default) for everything else.',
-    parameters: Type.Object({
-      taskId: Type.String({ description: "Task UUID" }),
-      deliverable: Type.String({
-        description: "Deliverable content (markdown or HTML depending on format)"
-      }),
-      format: Type.Optional(
-        Type.Union([Type.Literal("markdown"), Type.Literal("html")], {
-          description: '"markdown" (default) for text/documents, "html" for rich web content. HTML is rendered in a sandboxed iframe.'
+      taskId: Type.String({ description: "Task UUID to reopen" }),
+      reason: Type.Optional(
+        Type.String({
+          description: "Why this task is being reopened (shown in task thread as system message)"
         })
       )
     })
   },
-  COMPLETE_TASK: {
-    name: "deskfree_complete_task",
-    description: 'Finish a task. Outcome "done" = work complete for review. Outcome "blocked" = need human input. Both move to human.',
-    parameters: Type.Object({
-      taskId: Type.String({ description: "Task UUID" }),
-      outcome: Type.Union([Type.Literal("done"), Type.Literal("blocked")], {
-        description: '"done" = work complete, "blocked" = need human input'
-      })
-    })
-  },
   SEND_MESSAGE: {
     name: "deskfree_send_message",
-    description: "Send a message in the task thread (progress update, question, status report). Can also suggest follow-up tasks for human review by providing the suggestions parameter instead of content.",
+    description: "Send a message (progress update, question, status report). Used for communication outside of task threads.",
     parameters: Type.Object({
-      content: Type.Optional(
-        Type.String({
-          description: "Message content. Required unless suggestions is provided."
-        })
-      ),
+      content: Type.String({
+        description: "Message content."
+      }),
       taskId: Type.Optional(
         Type.String({
-          description: "Task UUID (optional if context provides it)"
+          description: "Task UUID (optional \u2014 threads into task if provided)"
         })
-      ),
-      suggestions: Type.Optional(
-        Type.Array(
-          Type.Object({
-            title: Type.String({ description: "Task title (max 200 chars)" }),
-            instructions: Type.Optional(
-              Type.String({
-                description: "Detailed instructions for the suggested task"
-              })
-            )
-          }),
-          {
-            description: "Suggest tasks for human review (1-10). The human will see approve/reject buttons for each. Provide this instead of content.",
-            minItems: 1,
-            maxItems: 10
-          }
-        )
       )
     })
   },
-  SUGGEST_TASKS: {
-    name: "deskfree_suggest_tasks",
-    description: 'Suggest tasks for human approval. Tasks are created with "suggested" status \u2014 the human approves or rejects each one. Use this to propose work before starting. Include detailed instructions as if briefing a contractor.',
+  PROPOSE: {
+    name: "deskfree_propose",
+    description: "Propose a plan for human approval. Nothing is created until the human reviews and approves in a modal. One initiative per call \u2014 make multiple calls for multiple initiatives. Include substeps as human-reviewable checklist items.",
     parameters: Type.Object({
-      suggestions: Type.Array(
+      initiative: Type.Optional(
+        Type.Union(
+          [
+            Type.String({
+              description: 'Existing initiative ID (e.g. "INI_123") to group tasks under'
+            }),
+            Type.Object(
+              {
+                title: Type.String({
+                  description: "New initiative title (max 200 chars)"
+                }),
+                content: Type.String({
+                  description: "Initiative content markdown \u2014 current state, approach, and next priorities"
+                })
+              },
+              {
+                description: "Create a new initiative \u2014 human approves it along with tasks"
+              }
+            )
+          ],
+          {
+            description: "Initiative to group tasks under. Pass an existing ID string, a {title, content} object to create new, or omit for general/no initiative."
+          }
+        )
+      ),
+      context: Type.Optional(
+        Type.String({
+          description: "Why this plan is being proposed \u2014 helps the human understand the reasoning behind the proposal"
+        })
+      ),
+      tasks: Type.Array(
         Type.Object({
           title: Type.String({
             description: "Task title \u2014 short, action-oriented (max 200 chars)"
@@ -7844,110 +7970,278 @@ var ORCHESTRATOR_TOOLS = {
               description: "Detailed instructions: what to do, why, what done looks like, known constraints"
             })
           ),
+          substeps: Type.Optional(
+            Type.Array(Type.String(), {
+              description: "Human-reviewable checklist items. The human can toggle each on/off before approving. Use for discrete steps within the task.",
+              minItems: 1,
+              maxItems: 20
+            })
+          ),
+          file: Type.Optional(
+            Type.Union(
+              [
+                Type.Object(
+                  {
+                    existingId: Type.String({
+                      description: "Existing file ID to link to this task"
+                    })
+                  },
+                  {
+                    description: "Link an existing file \u2014 bot receives its content when claiming the task"
+                  }
+                ),
+                Type.Object(
+                  {
+                    name: Type.String({
+                      description: "File name (max 200 chars)"
+                    }),
+                    description: Type.Optional(
+                      Type.String({
+                        description: "Brief description of the file's purpose"
+                      })
+                    )
+                  },
+                  {
+                    description: "Create a new file on approval \u2014 use when the task will produce a persistent document"
+                  }
+                )
+              ],
+              {
+                description: "File to link: { existingId } for existing files, or { name, description? } to create a new one on approval. Omit if no file needed."
+              }
+            )
+          ),
           estimatedTokens: Type.Optional(
             Type.Number({
               description: "Estimated token cost \u2014 consider files to read, reasoning, output"
             })
           ),
-          dependsOn: Type.Optional(
-            Type.Array(Type.String(), {
-              description: "Task IDs this suggestion depends on (blocks claiming until those are done)"
-            })
-          ),
-          initiativeId: Type.Optional(
+          scheduledFor: Type.Optional(
             Type.String({
-              description: "Link to existing initiative ID \u2014 set when this task belongs to an active initiative"
+              description: "ISO-8601 date for when this task should become available. Use for future-dated or recurring work."
             })
           )
         }),
         {
-          description: "Array of task suggestions (1-20)",
+          description: "Array of tasks to propose (1-20)",
           minItems: 1,
           maxItems: 20
         }
-      ),
-      parentTaskId: Type.Optional(
+      )
+    })
+  }
+};
+var SHARED_TOOLS = {
+  UPDATE_FILE: {
+    name: "deskfree_update_file",
+    description: `Update a file's content. Use this to save work to a persistent file linked to your task. Call incrementally as you build content. Use format="html" for rich web content; use format="markdown" (default) for everything else.`,
+    parameters: Type.Object({
+      fileId: Type.String({ description: "File ID to update" }),
+      content: Type.String({
+        description: "Full file content (replaces previous)"
+      }),
+      contentFormat: Type.Optional(
+        Type.Union([Type.Literal("markdown"), Type.Literal("html")], {
+          description: '"markdown" (default) for text/documents, "html" for rich web content.'
+        })
+      )
+    })
+  },
+  COMPLETE_TASK: {
+    name: "deskfree_complete_task",
+    description: 'Finish a task. Outcome "done" = work complete (summary required). Outcome "blocked" = need human input. Both move to human. For evaluation tasks (mode="evaluation"), include the evaluation object when outcome is "done".',
+    parameters: Type.Object({
+      taskId: Type.String({ description: "Task UUID" }),
+      outcome: Type.Union([Type.Literal("done"), Type.Literal("blocked")], {
+        description: '"done" = work complete, "blocked" = need human input'
+      }),
+      summary: Type.Optional(
         Type.String({
-          description: "Parent task ID \u2014 set when suggesting follow-ups from within a task"
+          description: 'Brief summary of what was accomplished (required for outcome "done", max 2000 chars)'
         })
       ),
-      initiativeSuggestions: Type.Optional(
-        Type.Array(
-          Type.Object({
-            title: Type.String({
-              description: "Initiative title (max 200 chars)"
-            }),
-            content: Type.String({
-              description: "Initiative content markdown \u2014 current state, approach, and next priorities"
+      evaluation: Type.Optional(
+        Type.Object(
+          {
+            reasoning: Type.String({
+              description: "Explanation of your evaluation \u2014 what you analyzed and why you did or did not update the ways of working and/or initiative content"
             }),
-            taskRefs: Type.Optional(
-              Type.Array(Type.Number(), {
-                description: "Indexes into suggestions[] to auto-link when this initiative is approved"
-              })
+            globalWoW: Type.Object(
+              {
+                hasChanges: Type.Boolean({
+                  description: "Whether the global ways of working should be updated"
+                }),
+                updatedContent: Type.Optional(
+                  Type.String({
+                    description: "Full updated global ways-of-working markdown (required if hasChanges=true)"
+                  })
+                )
+              },
+              {
+                description: "Global ways-of-working update \u2014 patterns that apply across all work"
+              }
+            ),
+            initiative: Type.Optional(
+              Type.Object(
+                {
+                  hasChanges: Type.Boolean({
+                    description: "Whether the initiative content should be updated (ignored if task has no initiative)"
+                  }),
+                  updatedContent: Type.Optional(
+                    Type.String({
+                      description: "Full updated initiative content markdown (required if hasChanges=true)"
+                    })
+                  )
+                },
+                {
+                  description: "Initiative content update \u2014 what was learned about this specific area of focus. Ignored if the task has no initiative_id."
+                }
+              )
             )
-          }),
+          },
           {
-            description: 'Propose new initiatives (optional). Created with "suggested" status \u2014 human approves or rejects independently.',
-            minItems: 1,
-            maxItems: 10
+            description: 'Required when completing an evaluation task (mode="evaluation") with outcome "done". Review global WoW and initiative content and provide your analysis.'
           }
         )
       )
     })
   },
-  CLAIM_EVALUATION: {
-    name: "deskfree_claim_evaluation",
-    description: "Claim a pending ways-of-working evaluation for a task. Returns the task, its message history, current global ways_of_working, and initiative data (if the task belongs to an initiative). Returns null if already claimed by another process.",
+  SEND_MESSAGE: {
+    name: "deskfree_send_message",
+    description: "Send a message in the task thread (progress update, question, status report).",
     parameters: Type.Object({
-      taskId: Type.String({ description: "Task UUID to claim evaluation for" })
+      content: Type.String({
+        description: "Message content."
+      }),
+      taskId: Type.Optional(
+        Type.String({
+          description: "Task UUID (optional if context provides it)"
+        })
+      )
     })
   },
-  SUBMIT_EVALUATION: {
-    name: "deskfree_submit_evaluation",
-    description: "Submit the result of a ways-of-working evaluation. Provide reasoning explaining your analysis. Evaluation has two independent outputs: globalWoW (applies everywhere) and initiative (applies to the specific initiative this task belongs to). Set hasChanges=true and provide updatedContent for each output you want to update.",
+  PROPOSE: {
+    name: "deskfree_propose",
+    description: "Propose a plan for human approval. Nothing is created until the human reviews and approves in a modal. One initiative per call \u2014 make multiple calls for multiple initiatives. Include substeps as human-reviewable checklist items.",
     parameters: Type.Object({
-      taskId: Type.String({ description: "Task UUID being evaluated" }),
-      reasoning: Type.String({
-        description: "Explanation of your evaluation \u2014 what you analyzed and why you did or did not update the ways of working and/or initiative content"
-      }),
-      globalWoW: Type.Object(
-        {
-          hasChanges: Type.Boolean({
-            description: "Whether the global ways of working should be updated"
-          }),
-          updatedContent: Type.Optional(
+      initiative: Type.Optional(
+        Type.Union(
+          [
             Type.String({
-              description: "Full updated global ways-of-working markdown (required if hasChanges=true)"
-            })
-          )
-        },
-        {
-          description: "Global ways-of-working update \u2014 patterns that apply across all work"
-        }
+              description: 'Existing initiative ID (e.g. "INI_123") to group tasks under'
+            }),
+            Type.Object(
+              {
+                title: Type.String({
+                  description: "New initiative title (max 200 chars)"
+                }),
+                content: Type.String({
+                  description: "Initiative content markdown \u2014 current state, approach, and next priorities"
+                })
+              },
+              {
+                description: "Create a new initiative \u2014 human approves it along with tasks"
+              }
+            )
+          ],
+          {
+            description: "Initiative to group tasks under. Pass an existing ID string, a {title, content} object to create new, or omit for general/no initiative."
+          }
+        )
       ),
-      initiative: Type.Object(
-        {
-          hasChanges: Type.Boolean({
-            description: "Whether the initiative content should be updated (ignored if task has no initiative)"
+      context: Type.Optional(
+        Type.String({
+          description: "Why this plan is being proposed \u2014 helps the human understand the reasoning behind the proposal"
+        })
+      ),
+      tasks: Type.Array(
+        Type.Object({
+          title: Type.String({
+            description: "Task title \u2014 short, action-oriented (max 200 chars)"
           }),
-          updatedContent: Type.Optional(
+          instructions: Type.Optional(
             Type.String({
-              description: "Full updated initiative content markdown (required if hasChanges=true)"
+              description: "Detailed instructions: what to do, why, what done looks like, known constraints"
+            })
+          ),
+          substeps: Type.Optional(
+            Type.Array(Type.String(), {
+              description: "Human-reviewable checklist items. The human can toggle each on/off before approving. Use for discrete steps within the task.",
+              minItems: 1,
+              maxItems: 20
+            })
+          ),
+          file: Type.Optional(
+            Type.Union(
+              [
+                Type.Object(
+                  {
+                    existingId: Type.String({
+                      description: "Existing file ID to link to this task"
+                    })
+                  },
+                  {
+                    description: "Link an existing file \u2014 bot receives its content when claiming the task"
+                  }
+                ),
+                Type.Object(
+                  {
+                    name: Type.String({
+                      description: "File name (max 200 chars)"
+                    }),
+                    description: Type.Optional(
+                      Type.String({
+                        description: "Brief description of the file's purpose"
+                      })
+                    )
+                  },
+                  {
+                    description: "Create a new file on approval \u2014 use when the task will produce a persistent document"
+                  }
+                )
+              ],
+              {
+                description: "File to link: { existingId } for existing files, or { name, description? } to create a new one on approval. Omit if no file needed."
+              }
+            )
+          ),
+          estimatedTokens: Type.Optional(
+            Type.Number({
+              description: "Estimated token cost \u2014 consider files to read, reasoning, output"
+            })
+          ),
+          scheduledFor: Type.Optional(
+            Type.String({
+              description: "ISO-8601 date for when this task should become available. Use for future-dated or recurring work."
             })
           )
-        },
+        }),
         {
-          description: "Initiative content update \u2014 what was learned about this specific area of focus. Ignored if the task has no initiative_id."
+          description: "Array of tasks to propose (1-20)",
+          minItems: 1,
+          maxItems: 20
         }
       )
     })
   }
 };
 var WORKER_TOOLS = {
-  UPDATE_DELIVERABLE: ORCHESTRATOR_TOOLS.UPDATE_DELIVERABLE,
-  COMPLETE_TASK: ORCHESTRATOR_TOOLS.COMPLETE_TASK,
-  SEND_MESSAGE: ORCHESTRATOR_TOOLS.SEND_MESSAGE,
-  SUBMIT_EVALUATION: ORCHESTRATOR_TOOLS.SUBMIT_EVALUATION
+  START_TASK: {
+    name: "deskfree_start_task",
+    description: 'Claim a bot task (isWorking=false) and start working. Returns full context (instructions, message history, and fileContext if the task has a linked file \u2014 use the file content as working context). For evaluation tasks, also returns WoW context and mode="evaluation".',
+    parameters: Type.Object({
+      taskId: Type.String({ description: "Task UUID to claim" }),
+      runnerId: Type.Optional(
+        Type.String({
+          description: "Runner/session identifier for tracking (max 100 chars)"
+        })
+      )
+    })
+  },
+  UPDATE_FILE: SHARED_TOOLS.UPDATE_FILE,
+  COMPLETE_TASK: SHARED_TOOLS.COMPLETE_TASK,
+  SEND_MESSAGE: SHARED_TOOLS.SEND_MESSAGE,
+  PROPOSE: SHARED_TOOLS.PROPOSE
 };
 var CHANNEL_META = {
   name: "DeskFree",
@@ -8504,24 +8798,30 @@ var deskFreePlugin = {
 };
 
 // src/context.ts
-var DESKFREE_AGENT_DIRECTIVE = `## DeskFree \u2014 The Work Loop
-Always read the deskfree skill (SKILL.md) at startup. Follow the suggest-first work loop:
-1. **Check state** \u2192 \`deskfree_state\` \u2014 see what needs attention, read ways of working.
-2. **Suggest tasks** \u2192 \`deskfree_suggest_tasks\` \u2014 ALL work requires human-approved tasks first.
-3. **Claim a task** \u2192 \`deskfree_start_task\` \u2014 read instructions + parent context carefully.
-4. **Do the work** \u2192 \`deskfree_update_deliverable\` incrementally from the start.
-5. **Suggest follow-ups** \u2192 if work reveals more to do, suggest them (strongest when you have full context).
-6. **Complete** \u2192 \`deskfree_complete_task\` \u2014 deliverable required for "done".
-7. **Evaluate** \u2192 check \`pendingEvaluations\` and update ways of working.
-
-Key principles:
-- You're building a chain. Your instructions become someone else's brief. Your deliverable becomes someone else's context.
-- Write instructions as if briefing a contractor who has never seen the codebase.
-- MUST update deliverable before completing with outcome "done".
-- Estimate token cost per suggestion \u2014 consider files to read, reasoning, output.
-- Sub-agents get 4 tools: update_deliverable, complete_task, send_message, submit_evaluation.`;
-function getDeskFreeContext() {
-  return `${DESKFREE_AGENT_DIRECTIVE}
+var DESKFREE_AGENT_DIRECTIVE = `## DeskFree \u2014 Orchestrator
+You are the orchestrator. You assess state, propose plans, and dispatch work to sub-agents.
+1. **Check state** \u2192 \`deskfree_state\` \u2014 see tasks, initiatives, ways of working.
+2. **Propose plan** \u2192 \`deskfree_propose\` \u2014 ALL work requires human-approved tasks first.
+3. **Dispatch** \u2192 spawn a sub-agent for each approved task. Pass the taskId \u2014 the sub-agent claims it.
+4. **Communicate** \u2192 \`deskfree_send_message\` for updates outside task threads.
+
+You do NOT claim tasks or do work directly. Sub-agents handle execution.
+- When a human writes in a task thread, you receive it with recent context. Use \`deskfree_reopen_task\` if it needs more work.
+- Write task instructions as if briefing a contractor who has never seen the codebase.
+- Estimate token cost per task \u2014 consider files to read, reasoning, output.
+- One initiative per proposal \u2014 make multiple calls for multiple initiatives.`;
+var DESKFREE_WORKER_DIRECTIVE = `## DeskFree Worker
+You are a worker sub-agent. Call \`deskfree_start_task\` with your taskId to claim and load context.
+Tools: deskfree_start_task, deskfree_update_file, deskfree_complete_task, deskfree_send_message, deskfree_propose.
+- Claim your task first with deskfree_start_task \u2014 this loads instructions, messages, and file context.
+- Save work to linked files with deskfree_update_file (incrementally).
+- Complete with deskfree_complete_task when done (summary required for outcome "done").
+- For evaluation tasks (mode="evaluation"), include the evaluation object in complete_task.
+- Propose follow-up tasks with deskfree_propose if you discover more work.`;
+function getDeskFreeContext(sessionKey) {
+  const isWorker = sessionKey && (sessionKey.includes(":sub:") || sessionKey.includes(":spawn:") || sessionKey.includes(":run:"));
+  const directive = isWorker ? DESKFREE_WORKER_DIRECTIVE : DESKFREE_AGENT_DIRECTIVE;
+  return `${directive}
 
 <!-- deskfree-plugin:${PLUGIN_VERSION} -->`;
 }
@@ -8558,15 +8858,7 @@ function formatTaskResponse(task, summary, nextActions) {
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            summary,
-            nextActions,
-            task
-          },
-          null,
-          2
-        )
+        text: JSON.stringify({ summary, nextActions, task }, null, 2)
       }
     ]
   };
@@ -8577,11 +8869,7 @@ function formatConfirmation(summary, nextActions, data) {
       {
         type: "text",
         text: JSON.stringify(
-          {
-            summary,
-            nextActions,
-            ...data ? { data } : {}
-          },
+          { summary, nextActions, ...data ? { data } : {} },
           null,
           2
         )
@@ -8642,14 +8930,7 @@ function errorResult(err) {
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            error: true,
-            message: rawMessage
-          },
-          null,
-          2
-        )
+        text: JSON.stringify({ error: true, message: rawMessage }, null, 2)
       }
     ],
     isError: true
@@ -8666,9 +8947,7 @@ function validateStringParam(params, key, required) {
   }
   const value = params[key];
   if (value == null) {
-    if (required) {
-      throw new Error(`Required parameter '${key}' is missing`);
-    }
+    if (required) throw new Error(`Required parameter '${key}' is missing`);
     return void 0;
   }
   if (typeof value !== "string") {
@@ -8679,34 +8958,124 @@ function validateStringParam(params, key, required) {
   }
   return value;
 }
-function validateEnumParam(params, key, allowedValues, required) {
-  if (!params) {
-    if (required) {
-      throw new Error(
-        `Required parameter '${key}' is missing (no params provided)`
-      );
+function parseProposeTasks(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    throw new Error('Parameter "tasks" must be a non-empty array');
+  }
+  return raw.map((s, i) => {
+    if (typeof s !== "object" || s === null) {
+      throw new Error(`tasks[${i}] must be an object`);
+    }
+    const item = s;
+    const title = item["title"];
+    if (typeof title !== "string" || title.trim() === "") {
+      throw new Error(`tasks[${i}].title must be a non-empty string`);
+    }
+    let substeps;
+    if (Array.isArray(item["substeps"]) && item["substeps"].length > 0) {
+      substeps = item["substeps"].filter((s2) => typeof s2 === "string" && s2.trim() !== "").map((s2) => s2.trim());
+      if (substeps.length === 0) substeps = void 0;
+    }
+    let file;
+    if (item["file"] && typeof item["file"] === "object") {
+      const f = item["file"];
+      if (typeof f["existingId"] === "string" && f["existingId"].trim()) {
+        file = { type: "existing", existingId: f["existingId"].trim() };
+      } else if (typeof f["name"] === "string" && f["name"].trim()) {
+        file = {
+          type: "new",
+          name: f["name"].trim(),
+          description: typeof f["description"] === "string" ? f["description"] : void 0
+        };
+      }
     }
-    return void 0;
-  }
-  const value = params[key];
-  if (value == null) {
-    if (required) {
-      throw new Error(`Required parameter '${key}' is missing`);
+    return {
+      title: title.trim(),
+      instructions: typeof item["instructions"] === "string" ? item["instructions"] : void 0,
+      substeps,
+      file,
+      estimatedTokens: typeof item["estimatedTokens"] === "number" ? item["estimatedTokens"] : void 0,
+      scheduledFor: typeof item["scheduledFor"] === "string" ? item["scheduledFor"] : void 0
+    };
+  });
+}
+function parseInitiative(raw) {
+  if (!raw) return void 0;
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "object") {
+    const obj = raw;
+    if (typeof obj["title"] === "string" && obj["title"].trim()) {
+      return {
+        title: String(obj["title"]).trim(),
+        content: String(obj["content"] ?? "")
+      };
     }
-    return void 0;
-  }
-  if (typeof value !== "string") {
-    throw new Error(`Parameter '${key}' must be a string, got ${typeof value}`);
-  }
-  if (required && value.trim() === "") {
-    throw new Error(`Required parameter '${key}' cannot be empty`);
-  }
-  if (!allowedValues.includes(value)) {
-    throw new Error(
-      `Parameter '${key}' must be one of: ${allowedValues.join(", ")}, got: ${value}`
-    );
   }
-  return value;
+  return void 0;
+}
+function makeReopenTaskHandler(client) {
+  return async (_id, params) => {
+    try {
+      const taskId = validateStringParam(params, "taskId", true);
+      const reason = validateStringParam(params, "reason", false);
+      const result = await client.reopenTask({ taskId, reason });
+      return formatTaskResponse(result, `Task "${result.title}" reopened`, [
+        "Task is now in bot queue \u2014 spawn a sub-agent to claim it"
+      ]);
+    } catch (err) {
+      return errorResult(err);
+    }
+  };
+}
+function makeSendMessageHandler(client) {
+  return async (_id, params) => {
+    try {
+      const content = validateStringParam(params, "content", true);
+      const taskId = validateStringParam(params, "taskId", false);
+      await client.sendMessage({ content, taskId });
+      return formatConfirmation(
+        `Message sent${taskId ? ` to task ${taskId}` : ""}`,
+        [
+          "Message delivered to the human",
+          taskId ? "Continue working on the task or wait for response" : "Check for response with task messages"
+        ]
+      );
+    } catch (err) {
+      return errorResult(err);
+    }
+  };
+}
+function makeProposeHandler(client) {
+  return async (_id, params) => {
+    try {
+      const tasks = parseProposeTasks(params?.tasks);
+      const context = validateStringParam(params, "context", false);
+      const initiative = parseInitiative(params?.initiative);
+      const result = await client.proposePlan({
+        tasks: tasks.map((t) => ({
+          title: t.title,
+          instructions: t.instructions,
+          substeps: t.substeps,
+          file: t.file,
+          estimatedTokens: t.estimatedTokens,
+          scheduledFor: t.scheduledFor
+        })),
+        initiative,
+        context: context ?? void 0
+      });
+      return formatConfirmation(
+        `Proposed ${tasks.length} task${tasks.length === 1 ? "" : "s"} for human approval`,
+        [
+          "Plan stored as proposal \u2014 NO tasks created until human approves",
+          "Human will review in the proposal modal and can edit/approve/reject each item",
+          "Use deskfree_state to check for approved tasks"
+        ],
+        result
+      );
+    } catch (err) {
+      return errorResult(err);
+    }
+  };
 }
 function createOrchestratorTools(api) {
   const account = resolveAccountFromConfig(api);
@@ -8727,336 +9096,16 @@ function createOrchestratorTools(api) {
       }
     },
     {
-      ...ORCHESTRATOR_TOOLS.START_TASK,
-      async execute(_id, params) {
-        try {
-          const taskId = validateStringParam(params, "taskId", true);
-          const result = await client.claimTask({ taskId });
-          setActiveTaskId(taskId);
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  {
-                    summary: `Claimed task "${result.title}" \u2014 full context loaded`,
-                    nextActions: [
-                      "Read the instructions and message history carefully",
-                      "Update deliverable incrementally with deskfree_update_deliverable",
-                      "Complete with deskfree_complete_task when done"
-                    ],
-                    task: result
-                  },
-                  null,
-                  2
-                )
-              }
-            ]
-          };
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
-    },
-    {
-      ...ORCHESTRATOR_TOOLS.UPDATE_DELIVERABLE,
-      async execute(_id, params) {
-        try {
-          const taskId = validateStringParam(params, "taskId", true);
-          const deliverable = validateStringParam(params, "deliverable", true);
-          const format = validateEnumParam(
-            params,
-            "format",
-            ["markdown", "html"],
-            false
-          );
-          await client.updateDeliverable({ taskId, deliverable, format });
-          return formatConfirmation(`Updated deliverable for task ${taskId}`, [
-            "Deliverable has been saved",
-            "Complete with deskfree_complete_task when ready"
-          ]);
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
-    },
-    {
-      ...ORCHESTRATOR_TOOLS.COMPLETE_TASK,
-      async execute(_id, params) {
-        try {
-          const taskId = validateStringParam(params, "taskId", true);
-          const outcome = validateEnumParam(
-            params,
-            "outcome",
-            ["done", "blocked"],
-            true
-          );
-          const result = await client.completeTask({ taskId, outcome });
-          setActiveTaskId(null);
-          const summaryVerb = outcome === "done" ? "completed" : "blocked";
-          const icon = outcome === "done" ? "\u2705" : "\u{1F6AB}";
-          await client.sendMessage({
-            content: `${icon} Task ${summaryVerb}: "${result.title}"`
-          }).catch(() => {
-          });
-          return formatTaskResponse(
-            result,
-            `Task "${result.title}" marked as ${summaryVerb} \u2014 waiting for human`,
-            [
-              outcome === "done" ? "Human will review the deliverable" : "Human will review the blocker and provide guidance",
-              "Use deskfree_state to check for other tasks"
-            ]
-          );
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
+      ...ORCHESTRATOR_TOOLS.REOPEN_TASK,
+      execute: makeReopenTaskHandler(client)
     },
     {
       ...ORCHESTRATOR_TOOLS.SEND_MESSAGE,
-      async execute(_id, params) {
-        try {
-          const content = validateStringParam(params, "content", false);
-          const taskId = validateStringParam(params, "taskId", false);
-          const rawSuggestions = params?.suggestions;
-          let suggestions;
-          if (Array.isArray(rawSuggestions) && rawSuggestions.length > 0) {
-            suggestions = rawSuggestions.map((t, i) => {
-              if (typeof t !== "object" || t === null) {
-                throw new Error(`suggestions[${i}] must be an object`);
-              }
-              const item = t;
-              const title = item["title"];
-              if (typeof title !== "string" || title.trim() === "") {
-                throw new Error(
-                  `suggestions[${i}].title must be a non-empty string`
-                );
-              }
-              const instructions = item["instructions"];
-              return {
-                title: title.trim(),
-                instructions: typeof instructions === "string" ? instructions : void 0
-              };
-            });
-          }
-          if (!content && !suggestions) {
-            throw new Error(
-              'Either "content" or "suggestions" parameter is required'
-            );
-          }
-          if (suggestions) {
-            await client.sendMessage({ suggestions, taskId });
-            return formatConfirmation(
-              `Suggested ${suggestions.length} task${suggestions.length === 1 ? "" : "s"} for human review`,
-              [
-                "The human will see approve/reject buttons for each suggestion",
-                "Continue working on the current task"
-              ]
-            );
-          }
-          await client.sendMessage({ content, taskId });
-          return formatConfirmation(
-            `Message sent${taskId ? ` to task ${taskId}` : ""}`,
-            [
-              "Message delivered to the human",
-              taskId ? "Continue working on the task or wait for response" : "Check for response with task messages"
-            ]
-          );
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
-    },
-    {
-      ...ORCHESTRATOR_TOOLS.SUGGEST_TASKS,
-      async execute(_id, params) {
-        try {
-          const rawSuggestions = params?.suggestions;
-          if (!Array.isArray(rawSuggestions) || rawSuggestions.length === 0) {
-            throw new Error(
-              'Parameter "suggestions" must be a non-empty array'
-            );
-          }
-          const suggestions = rawSuggestions.map((s, i) => {
-            if (typeof s !== "object" || s === null) {
-              throw new Error(`suggestions[${i}] must be an object`);
-            }
-            const item = s;
-            const title = item["title"];
-            if (typeof title !== "string" || title.trim() === "") {
-              throw new Error(
-                `suggestions[${i}].title must be a non-empty string`
-              );
-            }
-            return {
-              title: title.trim(),
-              instructions: typeof item["instructions"] === "string" ? item["instructions"] : void 0,
-              estimatedTokens: typeof item["estimatedTokens"] === "number" ? item["estimatedTokens"] : void 0,
-              dependsOn: Array.isArray(item["dependsOn"]) ? item["dependsOn"] : void 0,
-              initiativeId: typeof item["initiativeId"] === "string" ? item["initiativeId"] : void 0
-            };
-          });
-          const parentTaskId = validateStringParam(
-            params,
-            "parentTaskId",
-            false
-          );
-          const rawInitiativeSuggestions = params?.initiativeSuggestions;
-          let initiativeSuggestions;
-          if (Array.isArray(rawInitiativeSuggestions) && rawInitiativeSuggestions.length > 0) {
-            initiativeSuggestions = rawInitiativeSuggestions.map(
-              (s, i) => {
-                if (typeof s !== "object" || s === null) {
-                  throw new Error(`initiativeSuggestions[${i}] must be an object`);
-                }
-                const item = s;
-                const title = item["title"];
-                if (typeof title !== "string" || title.trim() === "") {
-                  throw new Error(
-                    `initiativeSuggestions[${i}].title must be a non-empty string`
-                  );
-                }
-                const content = item["content"];
-                if (typeof content !== "string") {
-                  throw new Error(
-                    `initiativeSuggestions[${i}].content must be a string`
-                  );
-                }
-                return {
-                  title: title.trim(),
-                  content,
-                  taskRefs: Array.isArray(item["taskRefs"]) ? item["taskRefs"] : void 0
-                };
-              }
-            );
-          }
-          const result = await client.suggestTasksDedicated({
-            suggestions,
-            parentTaskId,
-            initiativeSuggestions
-          });
-          const initiativeCount = initiativeSuggestions?.length ?? 0;
-          const summaryParts = [
-            `Suggested ${suggestions.length} task${suggestions.length === 1 ? "" : "s"} for human approval`,
-            ...initiativeCount > 0 ? [
-              `and ${initiativeCount} initiative${initiativeCount === 1 ? "" : "s"}`
-            ] : []
-          ];
-          return formatConfirmation(
-            summaryParts.join(" "),
-            [
-              'Tasks created with "suggested" status \u2014 human will approve or reject each',
-              ...initiativeCount > 0 ? ["Initiative suggestions created \u2014 human will approve or reject independently"] : [],
-              "Use deskfree_state to check for approved tasks"
-            ],
-            result
-          );
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
+      execute: makeSendMessageHandler(client)
     },
     {
-      ...ORCHESTRATOR_TOOLS.CLAIM_EVALUATION,
-      async execute(_id, params) {
-        try {
-          const taskId = validateStringParam(params, "taskId", true);
-          const result = await client.claimEvaluation({ taskId });
-          if (!result) {
-            return formatConfirmation(
-              "Evaluation already claimed by another process",
-              ["Use deskfree_state to check for other pending evaluations"]
-            );
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  {
-                    summary: `Claimed evaluation for task "${result.task.title}"`,
-                    nextActions: [
-                      "Review the task messages, current global ways of working, and initiative content (if present)",
-                      "Decide what to update: globalWoW (universal patterns), initiative (area-specific learnings), both, or neither",
-                      "Call deskfree_submit_evaluation with your analysis"
-                    ],
-                    task: result.task,
-                    waysOfWorking: result.waysOfWorking,
-                    currentVersion: result.currentVersion,
-                    messages: result.messages,
-                    ...result.initiative ? { initiative: result.initiative } : {}
-                  },
-                  null,
-                  2
-                )
-              }
-            ]
-          };
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
-    },
-    {
-      ...ORCHESTRATOR_TOOLS.SUBMIT_EVALUATION,
-      async execute(_id, params) {
-        try {
-          const taskId = validateStringParam(params, "taskId", true);
-          const reasoning = validateStringParam(params, "reasoning", true);
-          const rawGlobalWoW = params?.globalWoW;
-          if (typeof rawGlobalWoW !== "object" || rawGlobalWoW === null) {
-            throw new Error('Parameter "globalWoW" must be an object');
-          }
-          const globalWoWObj = rawGlobalWoW;
-          if (typeof globalWoWObj["hasChanges"] !== "boolean") {
-            throw new Error('Parameter "globalWoW.hasChanges" must be a boolean');
-          }
-          const globalWoW = {
-            hasChanges: globalWoWObj["hasChanges"],
-            updatedContent: typeof globalWoWObj["updatedContent"] === "string" ? globalWoWObj["updatedContent"] : void 0
-          };
-          const rawInitiative = params?.initiative;
-          if (typeof rawInitiative !== "object" || rawInitiative === null) {
-            throw new Error('Parameter "initiative" must be an object');
-          }
-          const initiativeObj = rawInitiative;
-          if (typeof initiativeObj["hasChanges"] !== "boolean") {
-            throw new Error('Parameter "initiative.hasChanges" must be a boolean');
-          }
-          const initiative = {
-            hasChanges: initiativeObj["hasChanges"],
-            updatedContent: typeof initiativeObj["updatedContent"] === "string" ? initiativeObj["updatedContent"] : void 0
-          };
-          const result = await client.submitEvaluation({
-            taskId,
-            reasoning,
-            globalWoW,
-            initiative
-          });
-          const parts = [];
-          if (globalWoW.hasChanges) {
-            parts.push(`global WoW \u2192 v${result.globalVersion}`);
-          }
-          if (initiative.hasChanges && result.initiativeVersion !== void 0) {
-            parts.push(`initiative \u2192 v${result.initiativeVersion}`);
-          }
-          const messageContent = parts.length > 0 ? `\u{1F4DD} Updated ${parts.join(", ")}: ${reasoning}` : `\u{1F4DD} No updates to ways of working: ${reasoning}`;
-          await client.sendMessage({ content: messageContent, taskId }).catch(() => {
-          });
-          const summaryParts = [];
-          if (globalWoW.hasChanges) summaryParts.push(`global WoW v${result.globalVersion}`);
-          if (initiative.hasChanges && result.initiativeVersion !== void 0) {
-            summaryParts.push(`initiative v${result.initiativeVersion}`);
-          }
-          return formatConfirmation(
-            summaryParts.length > 0 ? `Evaluation complete \u2014 updated ${summaryParts.join(", ")}` : "Evaluation complete \u2014 no changes needed",
-            ["Use deskfree_state to check for other pending evaluations"],
-            result
-          );
-        } catch (err) {
-          return errorResult(err);
-        }
-      }
+      ...ORCHESTRATOR_TOOLS.PROPOSE,
+      execute: makeProposeHandler(client)
     }
   ];
 }
@@ -9177,8 +9226,8 @@ var plugin = {
     api.registerTool(() => {
       return createOrchestratorTools(api);
     });
-    api.on("before_agent_start", (_event, _ctx) => {
-      return { prependContext: getDeskFreeContext() };
+    api.on("before_agent_start", (_event, ctx) => {
+      return { prependContext: getDeskFreeContext(ctx.sessionKey) };
     });
   }
 };