@questionbase/deskfree 0.6.1 → 0.6.3

package/dist/bin.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { homedir } from 'os';
+import { totalmem, cpus, hostname, arch, platform, homedir } from 'os';
 import { dirname, join, extname, basename } from 'path';
 import { spawn, execSync, execFileSync, execFile } from 'child_process';
-import { mkdirSync, writeFileSync, chmodSync, existsSync, unlinkSync, appendFileSync, readFileSync, statSync, createWriteStream } from 'fs';
+import { mkdirSync, readFileSync, existsSync, writeFileSync, chmodSync, unlinkSync, appendFileSync, statSync, createWriteStream } from 'fs';
 import { createRequire as createRequire$1 } from 'module';
 import { query, createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
@@ -109,7 +109,7 @@ var install_exports = {};
 __export(install_exports, {
   install: () => install
 });
-function installMac(token, name2) {
+function installMac(botId, name2, stage) {
   const paths = getMacPaths(name2);
   const plistLabel = getPlistLabel(name2);
   let nodeBinDir;
@@ -125,13 +125,9 @@ function installMac(token, name2) {
   mkdirSync(paths.deskfreeDir, { recursive: true });
   mkdirSync(paths.logDir, { recursive: true });
   mkdirSync(dirname(paths.plist), { recursive: true });
-  writeFileSync(
-    paths.envFile,
-    `DESKFREE_LAUNCH=${token}
-DESKFREE_INSTANCE_NAME=${name2}
-`,
-    { mode: 384 }
-  );
+  const envLines = [`BOT=${botId}`, `DESKFREE_INSTANCE_NAME=${name2}`];
+  if (stage) envLines.push(`STAGE=${stage}`);
+  writeFileSync(paths.envFile, envLines.join("\n") + "\n", { mode: 384 });
   chmodSync(paths.envFile, 384);
   console.log(`Wrote ${paths.envFile}`);
   const launcher = `#!/bin/bash
@@ -189,7 +185,7 @@ Service ${plistLabel} installed and started.`);
   console.log(`Check status: launchctl print gui/$(id -u)/${plistLabel}`);
   console.log(`Logs: tail -f ${join(paths.logDir, "stdout.log")}`);
 }
-function installLinux(token, name2) {
+function installLinux(botId, name2, stage) {
   if (process.getuid?.() !== 0) {
     console.error("Error: install must be run as root (use sudo)");
     process.exit(1);
@@ -220,13 +216,9 @@ function installLinux(token, name2) {
     `chown ${systemUser}:${systemUser} ${paths.stateDir} ${paths.logDir}`
   );
   console.log(`Created ${paths.stateDir} and ${paths.logDir}`);
-  writeFileSync(
-    paths.envFile,
-    `DESKFREE_LAUNCH=${token}
-DESKFREE_INSTANCE_NAME=${name2}
-`,
-    { mode: 384 }
-  );
+  const envLines = [`BOT=${botId}`, `DESKFREE_INSTANCE_NAME=${name2}`];
+  if (stage) envLines.push(`STAGE=${stage}`);
+  writeFileSync(paths.envFile, envLines.join("\n") + "\n", { mode: 384 });
   chmodSync(paths.envFile, 384);
   console.log(`Wrote ${paths.envFile}`);
   const unit = `[Unit]
@@ -264,11 +256,11 @@ Service ${serviceName} installed and started.`);
   console.log(`Check status: systemctl status ${serviceName}`);
   console.log(`Logs: tail -f ${paths.logDir}/stdout.log`);
 }
-function install(token, name2) {
+function install(botId, name2, stage) {
   if (process.platform === "darwin") {
-    installMac(token, name2);
+    installMac(botId, name2, stage);
   } else if (process.platform === "linux") {
-    installLinux(token, name2);
+    installLinux(botId, name2, stage);
   } else {
     console.error(`Unsupported platform: ${process.platform}`);
     process.exit(1);
@@ -2649,9 +2641,6 @@ function validateStringParam(params, key, required) {
 }
 function validateEnumParam(params, key, values, required) {
   const value = params?.[key];
-  if (required && (value === void 0 || value === null)) {
-    throw new Error(`Missing required parameter: ${key}`);
-  }
   if (value !== void 0 && value !== null && !values.includes(value)) {
     throw new Error(
       `Parameter ${key} must be one of: ${values.join(", ")}. Got: ${value}`
@@ -2740,34 +2729,33 @@ function createOrchestratorTools(client, _options) {
         return errorResult(err);
       }
     }),
-    createTool(ORCHESTRATOR_TOOLS.PROPOSE, async (params) => {
+    createTool(ORCHESTRATOR_TOOLS.CREATE_TASK, async (params) => {
       try {
-        const context = validateStringParam(params, "context", false);
-        const taskId = validateStringParam(params, "taskId", false);
-        const rawTasks = params.tasks;
-        if (!Array.isArray(rawTasks) || rawTasks.length === 0) {
-          throw new Error("tasks must be a non-empty array of task objects");
-        }
-        const tasks = rawTasks;
-        for (let i = 0; i < tasks.length; i++) {
-          const task = tasks[i];
-          if (!task || typeof task !== "object") {
-            throw new Error(`tasks[${i}] must be an object`);
-          }
-          if (!task.title || typeof task.title !== "string" || task.title.trim() === "") {
-            throw new Error(`tasks[${i}].title must be a non-empty string`);
-          }
-        }
-        await client.proposePlan({
-          context,
-          tasks,
-          taskId
+        const title = validateStringParam(params, "title", true);
+        const instructions = validateStringParam(params, "instructions", false);
+        const suggestedByTaskId = validateStringParam(
+          params,
+          "suggestedByTaskId",
+          false
+        );
+        const inputFileIds = Array.isArray(params.inputFileIds) ? params.inputFileIds : void 0;
+        const outputFileIds = Array.isArray(params.outputFileIds) ? params.outputFileIds : void 0;
+        const scheduledFor = validateStringParam(params, "scheduledFor", false);
+        const estimatedTokens = typeof params.estimatedTokens === "number" ? params.estimatedTokens : void 0;
+        const result = await client.createTask({
+          title,
+          instructions,
+          estimatedTokens,
+          scheduledFor,
+          inputFileIds,
+          outputFileIds,
+          suggestedByTaskId
         });
         return {
           content: [
             {
               type: "text",
-              text: `Proposal created with ${tasks.length} task(s)`
+              text: `Task created: "${result.title}" (${result.taskId})`
             }
           ]
         };
@@ -2787,15 +2775,36 @@ function createOrchestratorTools(client, _options) {
         return errorResult(err);
       }
     }),
-    createTool(ORCHESTRATOR_TOOLS.REOPEN_TASK, async (params) => {
+    createTool(ORCHESTRATOR_TOOLS.UPDATE_TASK_STATUS, async (params) => {
       try {
         const taskId = validateStringParam(params, "taskId", true);
+        const status2 = validateEnumParam(
+          params,
+          "status",
+          ["open", "done"],
+          false
+        );
+        const awaiting = validateEnumParam(
+          params,
+          "awaiting",
+          ["bot", "human"],
+          false
+        );
         const reason = validateStringParam(params, "reason", false);
-        const result = await client.reopenTask({ taskId, reason });
+        const result = await client.updateTaskStatus({
+          taskId,
+          status: status2,
+          awaiting,
+          reason
+        });
+        const details = [];
+        if (status2) details.push(`Status: ${status2}`);
+        if (awaiting) details.push(`Awaiting: ${awaiting}`);
+        if (reason) details.push(`Reason: ${reason}`);
         return formatTaskResponse(
           result,
-          `Task "${result.title}" reopened`,
-          reason ? [`Reason: ${reason}`] : []
+          `Task "${result.title}" updated`,
+          details
         );
       } catch (err) {
         return errorResult(err);
@@ -2867,18 +2876,7 @@ function createWorkerTools(client, options) {
       try {
         const content = validateStringParam(params, "content", true);
         const taskId = validateStringParam(params, "taskId", false);
-        const type = validateEnumParam(params, "type", ["notify", "ask"], true);
         await client.sendMessage({ content, taskId });
-        if (type === "ask") {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Ask sent \u2014 task is now awaiting human response. Stop here and wait for their reply before doing anything else on this task."
-              }
-            ]
-          };
-        }
         return {
           content: [{ type: "text", text: "Message sent successfully" }]
         };
@@ -2975,34 +2973,33 @@ function createWorkerTools(client, options) {
         return errorResult(err);
       }
     }),
-    createTool(WORKER_TOOLS.PROPOSE, async (params) => {
+    createTool(WORKER_TOOLS.CREATE_TASK, async (params) => {
       try {
-        const context = validateStringParam(params, "context", false);
-        const taskId = validateStringParam(params, "taskId", false);
-        const rawTasks = params.tasks;
-        if (!Array.isArray(rawTasks) || rawTasks.length === 0) {
-          throw new Error("tasks must be a non-empty array of task objects");
-        }
-        const tasks = rawTasks;
-        for (let i = 0; i < tasks.length; i++) {
-          const task = tasks[i];
-          if (!task || typeof task !== "object") {
-            throw new Error(`tasks[${i}] must be an object`);
-          }
-          if (!task.title || typeof task.title !== "string" || task.title.trim() === "") {
-            throw new Error(`tasks[${i}].title must be a non-empty string`);
-          }
-        }
-        await client.proposePlan({
-          context,
-          tasks,
-          taskId
+        const title = validateStringParam(params, "title", true);
+        const instructions = validateStringParam(params, "instructions", false);
+        const suggestedByTaskId = validateStringParam(
+          params,
+          "suggestedByTaskId",
+          false
+        );
+        const inputFileIds = Array.isArray(params.inputFileIds) ? params.inputFileIds : void 0;
+        const outputFileIds = Array.isArray(params.outputFileIds) ? params.outputFileIds : void 0;
+        const scheduledFor = validateStringParam(params, "scheduledFor", false);
+        const estimatedTokens = typeof params.estimatedTokens === "number" ? params.estimatedTokens : void 0;
+        const result = await client.createTask({
+          title,
+          instructions,
+          estimatedTokens,
+          scheduledFor,
+          inputFileIds,
+          outputFileIds,
+          suggestedByTaskId
         });
         return {
           content: [
             {
               type: "text",
-              text: `Proposal created with ${tasks.length} task(s)`
+              text: `Task created: "${result.title}" (${result.taskId})`
             }
           ]
         };
@@ -3025,22 +3022,42 @@ function createWorkerTools(client, options) {
         return errorResult(err);
       }
     }),
-    createTool(WORKER_TOOLS.COMPLETE_TASK, async (params) => {
+    createTool(WORKER_TOOLS.UPDATE_TASK_STATUS, async (params) => {
       try {
         const taskId = validateStringParam(params, "taskId", true);
-        const humanApproved = Boolean(params.humanApproved);
-        const result = await client.completeTask({
+        const status2 = validateEnumParam(
+          params,
+          "status",
+          ["open", "done"],
+          false
+        );
+        const awaiting = validateEnumParam(
+          params,
+          "awaiting",
+          ["bot", "human"],
+          false
+        );
+        const reason = validateStringParam(params, "reason", false);
+        const result = await client.updateTaskStatus({
           taskId,
-          humanApproved
+          status: status2,
+          awaiting,
+          reason
         });
-        try {
-          options?.onTaskCompleted?.(taskId);
-        } catch {
+        if (status2 === "done") {
+          try {
+            options?.onTaskCompleted?.(taskId);
+          } catch {
+          }
         }
+        const details = [];
+        if (status2) details.push(`Status: ${status2}`);
+        if (awaiting) details.push(`Awaiting: ${awaiting}`);
+        if (reason) details.push(`Reason: ${reason}`);
         return formatTaskResponse(
           result,
-          `Task "${result.title}" completed successfully`,
-          [humanApproved ? "Status: Human approved" : "Status: Completed"]
+          `Task "${result.title}" updated`,
+          details
         );
       } catch (err) {
         return errorResult(err);
@@ -3099,7 +3116,6 @@ Human attention is finite. You have unlimited stamina \u2014 they don't. Optimiz
 
 - **Don't pile on.** If the board already has 3+ open tasks, think twice before proposing more. Help finish and clear existing work before adding new items.
 - **Incremental over monolithic.** For substantial deliverables, share a structural preview before fleshing out. A quick "here's the outline \u2014 does this direction work?" saves everyone time versus a finished wall of text to review.
-- **Separate FYI from action needed.** Never make the human triage what needs their input. \`notify\` = no action needed. \`ask\` = needs their input. Be precise about which you're sending.
 - **Fewer, better decisions.** Don't present 5 options when you can recommend 1 with reasoning. Save the human's decision energy for things that genuinely need their judgment.
 - **Prefer simple output.** A focused 500-word draft beats a comprehensive 2000-word one the human has to pare down. Don't add sections, caveats, or "bonus" content unless asked.`;
 }
@@ -3108,26 +3124,26 @@ function buildAgentDirective(ctx) {
 
 ## How You Work
 
-**Main thread = short and snappy.** Keep responses to 1-3 sentences. Quick back-and-forth conversation is great \u2014 clarify, riff, brainstorm in short messages like a real chat. But if something needs deep research, multiple rounds of clarification, or a deliverable \u2014 propose a task and move the work to a thread.
+**Main thread = short and snappy.** Keep responses to 1-3 sentences. Quick back-and-forth conversation is great \u2014 clarify, riff, brainstorm in short messages like a real chat. But if something needs deep research, multiple rounds of clarification, or a deliverable \u2014 create a task and move the work to a thread.
 
 **The core loop:**
 
 1. **Check state** \u2014 use \`deskfree_state\` to see tasks and files. Use \`deskfree_orient\` to recall relevant memories.
-2. **Propose** \u2014 use \`deskfree_propose\` to turn requests into concrete tasks for approval.
-3. **Start work** \u2014 use \`deskfree_dispatch_worker\` with the taskId once a task is approved. You'll then continue the work in the task thread.
+2. **Create tasks** \u2014 use \`deskfree_create_task\` to turn requests into concrete tasks.
+3. **Start work** \u2014 use \`deskfree_dispatch_worker\` with the taskId to work on the task in a thread.
 4. **Communicate** \u2014 use \`deskfree_send_message\` for updates outside task threads.
 
-**Before proposing, qualify the request.** Figure out what kind of thing this is:
-- **One-off task** ("proofread this") \u2014 propose a task directly.
-- **New aspiration** ("I want to start posting on LinkedIn") \u2014 don't rush to propose. Ask 1-2 short qualifying questions to understand the real goal.
-- Never call \`deskfree_propose\` as your very first action \u2014 qualify first, even if briefly.
+**Before creating a task, qualify the request.** Figure out what kind of thing this is:
+- **One-off task** ("proofread this") \u2014 create a task directly.
+- **New aspiration** ("I want to start posting on LinkedIn") \u2014 don't rush to create a task. Ask 1-2 short qualifying questions to understand the real goal.
+- Never call \`deskfree_create_task\` as your very first action \u2014 qualify first, even if briefly.
 
 **Match the human's energy.** Short message \u2192 short reply. Casual tone \u2192 casual response. Don't over-explain, don't lecture, don't pad responses.
 
-In the main thread you propose and coordinate \u2014 the actual work happens in task threads. Use \`deskfree_dispatch_worker\` to start working on approved tasks.
+In the main thread you create tasks and coordinate \u2014 the actual work happens in task threads. Use \`deskfree_dispatch_worker\` to start working on tasks.
 - When a human writes in a task thread, decide:
   - **Continuation of the same task?** \u2192 reopen and pick it back up.
-  - **New/different work request?** \u2192 propose it as a new task (don't reopen the old one).
+  - **New/different work request?** \u2192 create it as a new task (don't reopen the old one).
   - **Just confirmation or deferred?** \u2192 leave it for now.
 - Estimate token cost per task \u2014 consider files to read, reasoning, output.
 
@@ -3151,7 +3167,7 @@ function buildWorkerDirective(ctx) {
 ## You're In a Task Thread
 You're the same ${ctx.botName} from the main thread, now focused on a specific task. Same voice, same personality \u2014 just heads-down on the work.
 
-Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_orient, deskfree_complete_task, deskfree_send_message, deskfree_propose.
+Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_orient, deskfree_update_task_status, deskfree_send_message, deskfree_create_task.
 
 **Context loading:**
 - If your first message contains \`<task_context>\`, the task is already loaded. Start working immediately \u2014 do NOT call deskfree_start_task.
@@ -3162,24 +3178,30 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - If no pre-loaded context (edge case/fallback), call \`deskfree_start_task\` with your taskId to load it.
 - If continuing from a previous conversation (you can see prior tool calls and context), respond directly to the human's latest message \u2014 do NOT call deskfree_start_task again.
 
+**Your text responses are automatically streamed to the human as messages.** You do NOT need to call \`deskfree_send_message\` to talk \u2014 just write your response text directly. Only use \`deskfree_send_message\` when you need to send a message mid-tool-execution (e.g. a progress update while doing file operations).
+
 **Orient \u2192 Align \u2192 Work.** Every new task follows this rhythm:
 
 1. **Orient** \u2014 Your first message includes operating memory and task-relevant memories. Read any relevant files with \`deskfree_read_file\`. If you need more context mid-task, use \`deskfree_orient\` with a specific query to recall relevant memories.
-2. **Align** \u2014 Send a brief \`notify\` message: what you found, what you'll produce. One or two sentences. ("I'll build on the existing brand guide and create a new tone reference.")
-   - **Judgment calls or creative direction?** State your assumptions and approach, send as \`ask\`, and wait for confirmation before proceeding. Getting alignment early prevents costly rework.
-   - **Straightforward execution?** Proceed immediately after the notify \u2014 don't wait for a response.
+2. **Align** \u2014 State briefly what you found and what you'll produce. One or two sentences. ("I'll build on the existing brand guide and create a new tone reference.") Just write this as your response text \u2014 do NOT use \`deskfree_send_message\`.
+   - **Judgment calls or creative direction?** State your assumptions and approach, then set \`awaiting: 'human'\` via \`deskfree_update_task_status\` and wait for confirmation before proceeding. Getting alignment early prevents costly rework.
+   - **Straightforward execution?** Proceed immediately \u2014 don't wait for a response.
 3. **Work** \u2014 Execute the task. Update existing files with \`deskfree_update_file\` or create new ones with \`deskfree_create_file\`. Pass your taskId so updates appear in the thread. For large deliverables, build incrementally \u2014 share structure/outline first, then flesh out. Don't produce a finished 2000-word document and ask for review in one shot.
-4. **Deliver** \u2014 Send an \`ask\` message when work is ready for review. Only complete (\`deskfree_complete_task\` with humanApproved: true) after the human has confirmed. Never self-complete.
+4. **Deliver** \u2014 When work is ready for review, set \`awaiting: 'human'\` via \`deskfree_update_task_status\`. The human will complete the task when satisfied.
 
 **Push back when warranted:**
 - If task instructions seem unclear, contradictory, or misguided \u2014 say so. "This task asks for X, but based on [context], Y might work better because..." is more useful than silently executing a flawed plan.
-- If you hit genuine ambiguity mid-task, send an \`ask\` message and wait. Don't guess on important decisions \u2014 guessing creates review debt the human has to pay later.
+- If you hit genuine ambiguity mid-task, send a message and set \`awaiting: 'human'\`. Don't guess on important decisions \u2014 guessing creates review debt the human has to pay later.
 - You're a teammate, not a task executor. Have an opinion when you have the context to form one.
 
+**New requests mid-task:**
+- When the human asks for something new in your thread, don't make it awkward \u2014 just roll with it. Qualify naturally ("Sure \u2014 what kind of audit?"), get enough clarity to write a well-scoped task, then use \`deskfree_create_task\`. No meta-commentary about scope boundaries or "that's outside this task." Just be a good conversationalist who happens to spin up a new task.
+- Every task needs a concrete deliverable and bounded scope. "Audit the codebase" is not a task \u2014 "Review tRPC error handling and list inconsistencies" is. If the human's request is too vague, ask a narrowing question before creating a task.
+- If you notice follow-up work yourself while executing, create a task immediately \u2014 don't wait until completion.
+
 **File rules:**
 - Create files when your task naturally produces them. Don't be afraid to create multiple files if the work calls for it.
 - Always pass \`taskId\` when creating or updating files \u2014 this threads notifications into the task.
-- If you discover work that falls outside your task's scope, use \`deskfree_propose\` to suggest follow-up tasks immediately \u2014 don't wait until completion. Propose as you discover, then stay focused on your current task.
 
 **Learnings \u2014 record aggressively:**
 Use \`deskfree_learning\` to record anything worth remembering. **Err on the side of recording too much** \u2014 the nightly sleep cycle will consolidate and prune. You lose nothing by over-recording, but you lose knowledge by under-recording.
@@ -3217,7 +3239,7 @@ On each heartbeat, run through this checklist:
 
 ### 1. Work the queue
 - Run \`deskfree_state\` to get the full workspace snapshot.
-- **Check board load.** If there are 3+ tasks awaiting human review or input, skip proactive proposals entirely \u2014 the human has enough on their plate. Focus only on dispatching approved work.
+- **Check board load.** If there are 3+ tasks awaiting human review or input, skip proactive task creation entirely \u2014 the human has enough on their plate. Focus only on dispatching approved work.
 - Any open tasks with awaiting=bot? Use \`deskfree_dispatch_worker\` to start working on each one. Pass the taskId.
 - Any open tasks that seem stalled (no recent activity)? Check on them.
 
@@ -3232,7 +3254,7 @@ After handling the queue, step back and think about the bigger picture. You have
 
 **Then act \u2014 but only if you have something genuinely useful:**
 
-*Things you can do* \u2014 research, drafts, analysis, prep. Propose as a task via \`deskfree_propose\`. One focused task, not a batch.
+*Things you can do* \u2014 research, drafts, analysis, prep. Create a task via \`deskfree_create_task\`. One focused task, not a batch.
 
 *Things the human should do* \u2014 nudges, reminders, conversation starters. Send via \`deskfree_send_message\`. Keep it brief and genuinely helpful, not nagging.
 
@@ -3248,7 +3270,7 @@ function buildSleepDirective(ctx) {
 ## Nightly Sleep Cycle \u2014 Memory Consolidation
 You're running your nightly cycle to consolidate observations into long-term memory.
 
-Tools available: deskfree_state, deskfree_propose, deskfree_send_message, deskfree_learning.
+Tools available: deskfree_state, deskfree_create_task, deskfree_send_message, deskfree_learning.
 
 Your job: classify new observations, decide merges/rewrites of existing entries, and write the operating memory summary. Code handles strength scoring, decay, archival, and dedup \u2014 you do semantics.
 
@@ -3335,16 +3357,16 @@ Write a ~1500 token markdown summary with these sections:
 After outputting the consolidation result:
 1. Call \`deskfree_state\` to see the board.
 2. Send a brief main-thread message via \`deskfree_send_message\` summarizing what was consolidated (1-2 sentences).
-3. Check for recurring commitments in operating memory \u2014 propose via \`deskfree_propose\` if needed.
-4. One proactive proposal max. Skip if nothing merits it or board is busy (3+ items needing human attention).`;
+3. Check for recurring commitments in operating memory \u2014 create via \`deskfree_create_task\` if needed.
+4. One proactive task max. Skip if nothing merits it or board is busy (3+ items needing human attention).`;
 }
 function buildDuskDirective(ctx) {
   return `${identityBlock(ctx)}
 
 ## Evening Dusk Cycle
-You're running your evening cycle to review the day, propose overnight work, and brief the human.
+You're running your evening cycle to review the day, create overnight tasks, and brief the human.
 
-Tools available: deskfree_state, deskfree_propose, deskfree_send_message, deskfree_read_file, deskfree_orient.
+Tools available: deskfree_state, deskfree_create_task, deskfree_send_message, deskfree_read_file, deskfree_orient.
 
 ---
 
@@ -3375,28 +3397,28 @@ Think about work that can be done autonomously overnight \u2014 WITHOUT human ju
 - Creative work where the human has strong opinions on direction
 - Anything the human explicitly said to wait on
 
-### 3. PROPOSE THE PLAN
+### 3. CREATE TASKS
 
 If you identified useful overnight work:
-1. **Check board load first.** Count open and awaiting-review tasks. If the human already has 3+ items needing their attention, limit to 1 proposal max \u2014 or skip entirely. Don't pile on.
-2. Use \`deskfree_propose\` with 1-3 well-scoped tasks. Quality over quantity.
+1. **Check board load first.** Count open and awaiting-review tasks. If the human already has 3+ items needing their attention, limit to 1 task max \u2014 or skip entirely. Don't pile on.
+2. Use \`deskfree_create_task\` to create 1-3 well-scoped tasks. Quality over quantity.
 3. Each task should be self-contained \u2014 it must be completable without human input.
 4. Set \`scheduledFor\` if work should start at a specific time (e.g. early morning).
-5. If nothing genuinely useful can be done overnight, skip the proposal entirely. Don't force it.
+5. If nothing genuinely useful can be done overnight, skip task creation entirely. Don't force it.
 
 ### 4. BRIEF THE HUMAN
 
 Send a brief main-thread message via \`deskfree_send_message\`:
 - 2-3 sentence summary: what happened today + what you're proposing for overnight (if anything).
 - Keep it conversational and useful \u2014 this is the human's "end of day" touchpoint.
-- If no proposals, still send a brief day summary.
+- If no tasks created, still send a brief day summary.
 
 ### Rules
-- Do NOT propose things already on the board or recently completed.
+- Do NOT create tasks for things already on the board or recently completed.
 - Do NOT repeat suggestions the human previously ignored or rejected.
 - Quality over quantity. One good task beats three mediocre ones.
 - Keep the briefing message short and actionable.
-- Cross-reference memory for recurring patterns \u2014 if something is due, propose it.
+- Cross-reference memory for recurring patterns \u2014 if something is due, create a task for it.
 - Use \`deskfree_read_file\` only if you need file content beyond what's in your prompt.`;
 }
 function setActiveWs(ws) {
@@ -3540,31 +3562,25 @@ function validateField(opts) {
     return patternMessage ?? `${name2} contains invalid characters`;
   return null;
 }
-function isLocalDevelopmentHost(hostname) {
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".local") || hostname.endsWith(".localhost") || /^192\.168\./.test(hostname) || /^10\./.test(hostname) || /^172\.(1[6-9]|2\d|3[01])\./.test(hostname);
+function isLocalDevelopmentHost(hostname2) {
+  return hostname2 === "localhost" || hostname2 === "127.0.0.1" || hostname2 === "::1" || hostname2.endsWith(".local") || hostname2.endsWith(".localhost") || /^192\.168\./.test(hostname2) || /^10\./.test(hostname2) || /^172\.(1[6-9]|2\d|3[01])\./.test(hostname2);
 }
-function validateBotToken(value) {
-  const fieldError = validateField({ value, name: "Bot token" });
+function validateBotId(value) {
+  const fieldError = validateField({ value, name: "Bot ID" });
   if (fieldError) return fieldError;
   const trimmed = value.trim();
-  if (!trimmed.startsWith("bot_")) {
-    return 'Bot token must start with "bot_" (check your DeskFree bot configuration)';
+  if (trimmed.includes(" ") || trimmed.includes("\n") || trimmed.includes("	")) {
+    return "Bot ID contains whitespace characters. Please copy it exactly as shown in DeskFree.";
   }
   const patternError = validateField({
     value,
-    name: "Bot token",
+    name: "Bot ID",
     minLength: 10,
-    maxLength: 200,
-    pattern: /^bot_[a-zA-Z0-9_-]+$/,
-    patternMessage: 'Bot token contains invalid characters. Only alphanumeric, underscore, and dash are allowed after "bot_"'
+    maxLength: 14,
+    pattern: /^[A-Z][A-Z0-9]+$/,
+    patternMessage: "Bot ID contains invalid characters. Only uppercase letters and numbers are allowed."
   });
   if (patternError) return patternError;
-  if (trimmed.includes(" ") || trimmed.includes("\n") || trimmed.includes("	")) {
-    return "Bot token contains whitespace characters. Please copy the token exactly as shown in DeskFree.";
-  }
-  if (trimmed === "bot_your_token_here" || trimmed === "bot_example") {
-    return "Please replace the placeholder with your actual bot token from DeskFree";
-  }
   return null;
 }
 function validateUrl(value, name2, allowedProtocols, protocolError) {
@@ -7351,13 +7367,13 @@ var init_dist = __esm({
       }
     };
     DeskFreeClient = class {
-      botToken;
+      getToken;
       apiUrl;
       requestTimeoutMs;
-      constructor(botToken, apiUrl, options) {
-        this.botToken = botToken;
-        this.apiUrl = apiUrl.replace(/\/$/, "");
-        this.requestTimeoutMs = options?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+      constructor(options) {
+        this.getToken = options.getToken;
+        this.apiUrl = options.apiUrl.replace(/\/$/, "");
+        this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       }
       async request(method, procedure, input) {
         const url = method === "GET" && input ? `${this.apiUrl}/${procedure}?input=${encodeURIComponent(JSON.stringify(input))}` : `${this.apiUrl}/${procedure}`;
@@ -7367,7 +7383,7 @@ var init_dist = __esm({
           const response = await fetch(url, {
             method,
             headers: {
-              Authorization: `Bot ${this.botToken}`,
+              Authorization: `Bearer ${this.getToken()}`,
               "Content-Type": "application/json"
             },
             body: method === "POST" ? JSON.stringify(input) : void 0,
@@ -7498,15 +7514,10 @@ var init_dist = __esm({
         this.requireNonEmpty(input.taskId, "taskId");
         return this.request("POST", "tasks.reportUsage", input);
       }
-      /** Complete a task. Marks it as done. */
-      async completeTask(input) {
-        this.requireNonEmpty(input.taskId, "taskId");
-        return this.request("POST", "tasks.complete", input);
-      }
-      /** Reopen a completed/human task back to bot status for further work. */
-      async reopenTask(input) {
+      /** Update task status and/or awaiting state. */
+      async updateTaskStatus(input) {
         this.requireNonEmpty(input.taskId, "taskId");
-        return this.request("POST", "tasks.reopen", input);
+        return this.request("POST", "tasks.updateStatus", input);
       }
       /** Snooze a task until a specified time. Task is hidden from active queues until then. */
       async snoozeTask(input) {
@@ -7545,17 +7556,9 @@ var init_dist = __esm({
       async consolidateMemory(input) {
         return this.request("POST", "memory.consolidate", 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."
-          );
-        }
-        return this.request("POST", "tasks.propose", input);
+      /** Create a task directly — no approval needed. */
+      async createTask(input) {
+        return this.request("POST", "tasks.create", input);
       }
       /**
        * Fetch runtime bootstrap config from the backend.
@@ -7580,7 +7583,7 @@ var init_dist = __esm({
             {
               method: "GET",
               headers: {
-                Authorization: `Bot ${this.botToken}`,
+                Authorization: `Bearer ${this.getToken()}`,
                 "Content-Type": "application/json"
               },
               signal: controller.signal
@@ -7922,14 +7925,24 @@ var init_dist = __esm({
           })
         })
       },
-      REOPEN_TASK: {
-        name: "deskfree_reopen_task",
-        description: "Reopen a task (from review or done) back to pending. Use when more work is needed on a task. Works on both completed and in-review tasks.",
+      UPDATE_TASK_STATUS: {
+        name: "deskfree_update_task_status",
+        description: "Update a task's status and/or awaiting state. Use to reopen done tasks, mark tasks done, or change who the task is awaiting.",
         parameters: Type.Object({
-          taskId: Type.String({ description: "Task UUID to reopen" }),
+          taskId: Type.String({ description: "Task UUID to update" }),
+          status: Type.Optional(
+            Type.Union([Type.Literal("open"), Type.Literal("done")], {
+              description: "New status (open or done)"
+            })
+          ),
+          awaiting: Type.Optional(
+            Type.Union([Type.Literal("bot"), Type.Literal("human")], {
+              description: "Who the task is awaiting (bot or human). Set to human when work is ready for review."
+            })
+          ),
           reason: Type.Optional(
             Type.String({
-              description: "Why this task is being reopened (shown in task thread as system message)"
+              description: "Brief explanation (shown in task thread as system message)"
             })
           )
         })
@@ -7938,9 +7951,6 @@ var init_dist = __esm({
         name: "deskfree_send_message",
         description: "Send a message to the human. Keep it short \u2014 1-3 sentences. No walls of text.",
         parameters: Type.Object({
-          type: Type.Union([Type.Literal("notify"), Type.Literal("ask")], {
-            description: "notify = general update (quiet). ask = needs human attention (surfaces prominently)."
-          }),
           content: Type.String({
             description: "Message content."
           }),
@@ -7951,63 +7961,49 @@ var init_dist = __esm({
           )
         })
       },
-      PROPOSE: {
-        name: "deskfree_propose",
-        description: "Propose a plan for human approval. Nothing is created until the human reviews and approves in a modal. Put all details in the instructions field using simple markdown (bold, lists, inline code). Do NOT use markdown headers (#) \u2014 use **bold text** instead for section labels.",
+      CREATE_TASK: {
+        name: "deskfree_create_task",
+        description: "Create a task directly. The task is created immediately and available for work. Put all details in the instructions field using simple markdown (bold, lists, inline code). Do NOT use markdown headers (#) \u2014 use **bold text** instead for section labels.",
         parameters: Type.Object({
-          context: Type.Optional(
+          title: Type.String({
+            description: "Task title \u2014 short, action-oriented (max 200 chars)"
+          }),
+          instructions: Type.Optional(
             Type.String({
-              description: "Why this plan is being proposed \u2014 helps the human understand the reasoning behind the proposal"
+              description: "Detailed instructions, constraints, or context for the task."
             })
           ),
-          tasks: Type.Array(
-            Type.Object({
-              title: Type.String({
-                description: "Task title \u2014 short, action-oriented (max 200 chars)"
-              }),
-              instructions: Type.Optional(
-                Type.String({
-                  description: "Detailed instructions, constraints, or context for the task."
-                })
-              ),
-              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."
-                })
-              ),
-              inputFileIds: Type.Optional(
-                Type.Array(
-                  Type.String({ description: "File ID to pre-load as context" }),
-                  {
-                    description: "File IDs to read as context input for this task",
-                    maxItems: 20
-                  }
-                )
-              ),
-              outputFileIds: Type.Optional(
-                Type.Array(
-                  Type.String({ description: "File ID to update as deliverable" }),
-                  {
-                    description: "File IDs this task will produce or update",
-                    maxItems: 10
-                  }
-                )
-              )
-            }),
-            {
-              description: "Array of tasks to propose (1-20)",
-              minItems: 1,
-              maxItems: 20
-            }
+          estimatedTokens: Type.Optional(
+            Type.Number({
+              description: "Estimated token cost \u2014 consider files to read, reasoning, output"
+            })
           ),
-          taskId: Type.Optional(
+          scheduledFor: Type.Optional(
+            Type.String({
+              description: "ISO-8601 date for when this task should become available. Use for future-dated or recurring work."
+            })
+          ),
+          inputFileIds: Type.Optional(
+            Type.Array(
+              Type.String({ description: "File ID to pre-load as context" }),
+              {
+                description: "File IDs to read as context input for this task",
+                maxItems: 20
+              }
+            )
+          ),
+          outputFileIds: Type.Optional(
+            Type.Array(
+              Type.String({ description: "File ID to update as deliverable" }),
+              {
+                description: "File IDs this task will produce or update",
+                maxItems: 10
+              }
+            )
+          ),
+          suggestedByTaskId: Type.Optional(
             Type.String({
-              description: "Task ID to thread this proposal into (for follow-up proposals from within a task)"
+              description: "Parent task ID (for follow-up tasks created from within a task thread)"
             })
           )
         })
@@ -8072,23 +8068,10 @@ var init_dist = __esm({
           )
         })
       },
-      COMPLETE_TASK: {
-        name: "deskfree_complete_task",
-        description: "Mark a task as done. Only call when truly finished and human confirmed.",
-        parameters: Type.Object({
-          taskId: Type.String({ description: "Task UUID" }),
-          humanApproved: Type.Boolean({
-            description: "Must be true. Confirms the human reviewed and approved completion. Backend validates a human message exists after your last ask."
-          })
-        })
-      },
       SEND_MESSAGE: {
         name: "deskfree_send_message",
         description: "Send a message in the task thread. Keep it short \u2014 1-3 sentences.",
         parameters: Type.Object({
-          type: Type.Union([Type.Literal("notify"), Type.Literal("ask")], {
-            description: "notify = progress update (quiet, collapsible). ask = needs human attention (surfaces to main thread). Terminate after sending an ask."
-          }),
           content: Type.String({
             description: "Message content."
           }),
@@ -8099,63 +8082,49 @@ var init_dist = __esm({
           )
         })
       },
-      PROPOSE: {
-        name: "deskfree_propose",
-        description: "Propose a plan for human approval. Nothing is created until the human reviews and approves in a modal. Put all details in the instructions field using simple markdown (bold, lists, inline code). Do NOT use markdown headers (#) \u2014 use **bold text** instead for section labels.",
+      CREATE_TASK: {
+        name: "deskfree_create_task",
+        description: "Create a task directly. The task is created immediately and available for work. Put all details in the instructions field using simple markdown (bold, lists, inline code). Do NOT use markdown headers (#) \u2014 use **bold text** instead for section labels.",
         parameters: Type.Object({
-          context: Type.Optional(
+          title: Type.String({
+            description: "Task title \u2014 short, action-oriented (max 200 chars)"
+          }),
+          instructions: Type.Optional(
             Type.String({
-              description: "Why this plan is being proposed \u2014 helps the human understand the reasoning behind the proposal"
+              description: "Detailed instructions, constraints, or context for the task."
             })
           ),
-          tasks: Type.Array(
-            Type.Object({
-              title: Type.String({
-                description: "Task title \u2014 short, action-oriented (max 200 chars)"
-              }),
-              instructions: Type.Optional(
-                Type.String({
-                  description: "Detailed instructions, constraints, or context for the task."
-                })
-              ),
-              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."
-                })
-              ),
-              inputFileIds: Type.Optional(
-                Type.Array(
-                  Type.String({ description: "File ID to pre-load as context" }),
-                  {
-                    description: "File IDs to read as context input for this task",
-                    maxItems: 20
-                  }
-                )
-              ),
-              outputFileIds: Type.Optional(
-                Type.Array(
-                  Type.String({ description: "File ID to update as deliverable" }),
-                  {
-                    description: "File IDs this task will produce or update",
-                    maxItems: 10
-                  }
-                )
-              )
-            }),
-            {
-              description: "Array of tasks to propose (1-20)",
-              minItems: 1,
-              maxItems: 20
-            }
+          estimatedTokens: Type.Optional(
+            Type.Number({
+              description: "Estimated token cost \u2014 consider files to read, reasoning, output"
+            })
           ),
-          taskId: Type.Optional(
+          scheduledFor: Type.Optional(
+            Type.String({
+              description: "ISO-8601 date for when this task should become available. Use for future-dated or recurring work."
+            })
+          ),
+          inputFileIds: Type.Optional(
+            Type.Array(
+              Type.String({ description: "File ID to pre-load as context" }),
+              {
+                description: "File IDs to read as context input for this task",
+                maxItems: 20
+              }
+            )
+          ),
+          outputFileIds: Type.Optional(
+            Type.Array(
+              Type.String({ description: "File ID to update as deliverable" }),
+              {
+                description: "File IDs this task will produce or update",
+                maxItems: 10
+              }
+            )
+          ),
+          suggestedByTaskId: Type.Optional(
             Type.String({
-              description: "Task ID to thread this proposal into (for follow-up proposals from within a task)"
+              description: "Parent task ID (for follow-up tasks created from within a task thread)"
             })
           )
         })
@@ -8229,34 +8198,55 @@ var init_dist = __esm({
           )
         })
       },
-      COMPLETE_TASK: SHARED_TOOLS.COMPLETE_TASK,
+      UPDATE_TASK_STATUS: {
+        name: "deskfree_update_task_status",
+        description: "Update a task's status and/or awaiting state. Use to mark tasks done, reopen them, or signal that you're awaiting human input.",
+        parameters: Type.Object({
+          taskId: Type.String({ description: "Task UUID to update" }),
+          status: Type.Optional(
+            Type.Union([Type.Literal("open"), Type.Literal("done")], {
+              description: "New status (open or done)"
+            })
+          ),
+          awaiting: Type.Optional(
+            Type.Union([Type.Literal("bot"), Type.Literal("human")], {
+              description: "Who the task is awaiting. Set to human when work is ready for review."
+            })
+          ),
+          reason: Type.Optional(
+            Type.String({
+              description: "Brief explanation (shown in task thread)"
+            })
+          )
+        })
+      },
       SEND_MESSAGE: SHARED_TOOLS.SEND_MESSAGE,
-      PROPOSE: SHARED_TOOLS.PROPOSE
+      CREATE_TASK: SHARED_TOOLS.CREATE_TASK
     };
     MAX_FULL_MESSAGES = 15;
     DESKFREE_AGENT_DIRECTIVE = `## DeskFree \u2014 Main Thread
-You handle the main conversation thread. Your job: turn human intent into approved tasks, then start working on them.
+You handle the main conversation thread. Your job: turn human intent into concrete tasks, then start working on them.
 
-**Main thread = short and snappy.** Keep responses to 1-3 sentences. Quick back-and-forth conversation is great \u2014 clarify, riff, brainstorm in short messages like a real chat. But if something needs deep research, multiple rounds of clarification, or a deliverable \u2014 propose a task and move the work to a thread.
+**Main thread = short and snappy.** Keep responses to 1-3 sentences. Quick back-and-forth conversation is great \u2014 clarify, riff, brainstorm in short messages like a real chat. But if something needs deep research, multiple rounds of clarification, or a deliverable \u2014 create a task and move the work to a thread.
 
-**The core loop: propose \u2192 approve \u2192 work.**
+**The core loop:**
 
 1. **Check state** \u2192 \`deskfree_state\` \u2014 see tasks and files. Use \`deskfree_orient\` to recall relevant memories.
-2. **Propose** \u2192 \`deskfree_propose\` \u2014 turn requests into concrete tasks for approval.
-3. **Start work** \u2192 \`deskfree_dispatch_worker\` with the taskId. You'll then continue the work in the task thread.
+2. **Create tasks** \u2192 \`deskfree_create_task\` \u2014 turn requests into concrete tasks.
+3. **Start work** \u2192 \`deskfree_dispatch_worker\` with the taskId to work on the task in a thread.
 4. **Communicate** \u2192 \`deskfree_send_message\` for updates outside task threads.
 
-**Before proposing, qualify the request.** Figure out what kind of thing this is:
-- **One-off task** ("proofread this") \u2192 propose a task directly.
-- **New aspiration** ("I want to start posting on LinkedIn") \u2192 don't rush to propose. Ask 1-2 short qualifying questions to understand the real goal.
-- Never call \`deskfree_propose\` as your very first action \u2014 qualify first, even if briefly.
+**Before creating a task, qualify the request.** Figure out what kind of thing this is:
+- **One-off task** ("proofread this") \u2192 create a task directly.
+- **New aspiration** ("I want to start posting on LinkedIn") \u2192 don't rush to create a task. Ask 1-2 short qualifying questions to understand the real goal.
+- Never call \`deskfree_create_task\` as your very first action \u2014 qualify first, even if briefly.
 
 **Match the human's energy.** Short message \u2192 short reply. Casual tone \u2192 casual response. Don't over-explain, don't lecture, don't pad responses.
 
-In the main thread you propose and coordinate \u2014 the actual work happens in task threads. Use \`deskfree_dispatch_worker\` to start working on approved tasks.
+In the main thread you create tasks and coordinate \u2014 the actual work happens in task threads. Use \`deskfree_dispatch_worker\` to start working on tasks.
 - When a human writes in a task thread, decide:
   - **Continuation of the same task?** \u2192 reopen and pick it back up.
-  - **New/different work request?** \u2192 propose it as a new task (don't reopen the old one).
+  - **New/different work request?** \u2192 create it as a new task (don't reopen the old one).
   - **Just confirmation or deferred?** \u2192 leave it for now.
 - Estimate token cost per task \u2014 consider files to read, reasoning, output.
 
@@ -8276,7 +8266,7 @@ Record immediately when: the human corrects you, expresses a preference, shares
     DESKFREE_WORKER_DIRECTIVE = `## DeskFree \u2014 Task Thread
 You're in a task thread, focused on a specific piece of work. Same you as in the main thread \u2014 same voice, same personality.
 
-Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_orient, deskfree_complete_task, deskfree_send_message, deskfree_propose.
+Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_orient, deskfree_update_task_status, deskfree_send_message, deskfree_create_task.
 
 **Context loading:**
 - If your first message contains \`<task_context>\`, the task is already loaded. Start working immediately \u2014 do NOT call deskfree_start_task.
@@ -8287,24 +8277,30 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - If no pre-loaded context (edge case/fallback), call \`deskfree_start_task\` with your taskId to load it.
 - If continuing from a previous conversation (you can see prior tool calls and context), respond directly to the human's latest message \u2014 do NOT call deskfree_start_task again.
 
+**Your text responses are automatically streamed to the human as messages.** You do NOT need to call \`deskfree_send_message\` to talk \u2014 just write your response text directly. Only use \`deskfree_send_message\` when you need to send a message mid-tool-execution (e.g. a progress update while doing file operations).
+
 **Orient \u2192 Align \u2192 Work.** Every new task follows this rhythm:
 
 1. **Orient** \u2014 Your first message includes operating memory and task-relevant memories. Read any relevant files with \`deskfree_read_file\`. If you need more context mid-task, use \`deskfree_orient\` with a specific query to recall relevant memories.
-2. **Align** \u2014 Send a brief \`notify\` message: what you found, what you'll produce. One or two sentences. ("I'll build on the existing brand guide and create a new tone reference.")
-   - **Judgment calls or creative direction?** State your assumptions and approach, send as \`ask\`, and wait for confirmation before proceeding. Getting alignment early prevents costly rework.
-   - **Straightforward execution?** Proceed immediately after the notify \u2014 don't wait for a response.
+2. **Align** \u2014 State briefly what you found and what you'll produce. One or two sentences. ("I'll build on the existing brand guide and create a new tone reference.") Just write this as your response text \u2014 do NOT use \`deskfree_send_message\`.
+   - **Judgment calls or creative direction?** State your assumptions and approach, then set \`awaiting: 'human'\` via \`deskfree_update_task_status\` and wait for confirmation before proceeding. Getting alignment early prevents costly rework.
+   - **Straightforward execution?** Proceed immediately \u2014 don't wait for a response.
 3. **Work** \u2014 Execute the task. Update existing files with \`deskfree_update_file\` or create new ones with \`deskfree_create_file\`. Pass your taskId so updates appear in the thread. For large deliverables, build incrementally \u2014 share structure/outline first, then flesh out. Don't produce a finished 2000-word document and ask for review in one shot.
-4. **Deliver** \u2014 Send an \`ask\` message when work is ready for review. Only complete (\`deskfree_complete_task\` with humanApproved: true) after the human has confirmed. Never self-complete.
+4. **Deliver** \u2014 When work is ready for review, set \`awaiting: 'human'\` via \`deskfree_update_task_status\`. The human will complete the task when satisfied.
 
 **Push back when warranted:**
 - If task instructions seem unclear, contradictory, or misguided \u2014 say so. "This task asks for X, but based on [context], Y might work better because..." is more useful than silently executing a flawed plan.
-- If you hit genuine ambiguity mid-task, send an \`ask\` message and wait. Don't guess on important decisions \u2014 guessing creates review debt the human has to pay later.
+- If you hit genuine ambiguity mid-task, send a message and set \`awaiting: 'human'\`. Don't guess on important decisions \u2014 guessing creates review debt the human has to pay later.
 - You're a teammate, not a task executor. Have an opinion when you have the context to form one.
 
+**New requests mid-task:**
+- When the human asks for something new in your thread, don't make it awkward \u2014 just roll with it. Qualify naturally ("Sure \u2014 what kind of audit?"), get enough clarity to write a well-scoped task, then use \`deskfree_create_task\`. No meta-commentary about scope boundaries or "that's outside this task." Just be a good conversationalist who happens to spin up a new task.
+- Every task needs a concrete deliverable and bounded scope. "Audit the codebase" is not a task \u2014 "Review tRPC error handling and list inconsistencies" is. If the human's request is too vague, ask a narrowing question before creating a task.
+- If you notice follow-up work yourself while executing, create a task immediately \u2014 don't wait until completion.
+
 **File rules:**
 - Create files when your task naturally produces them. Don't be afraid to create multiple files if the work calls for it.
 - Always pass \`taskId\` when creating or updating files \u2014 this threads notifications into the task.
-- If you discover work that falls outside your task's scope, use \`deskfree_propose\` to suggest follow-up tasks immediately \u2014 don't wait until completion. Propose as you discover, then stay focused on your current task.
 
 **Learnings \u2014 record aggressively:**
 Use \`deskfree_learning\` to record anything worth remembering. **Err on the side of recording too much** \u2014 the nightly sleep cycle will consolidate and prune. You lose nothing by over-recording, but you lose knowledge by under-recording.
@@ -8644,43 +8640,31 @@ var init_orchestrator = __esm({
     ];
   }
 });
-function requireEnv(key) {
-  const val = process.env[key];
-  if (!val) {
-    throw new Error(`Required environment variable ${key} is not set`);
-  }
-  return val;
+function getStageDomain(stage, domain) {
+  if (domain.startsWith(`${stage}.`)) return domain;
+  return `${stage}.${domain}`;
+}
+function deriveApiUrl() {
+  const domain = process.env["DESKFREE_DOMAIN"] ?? "dev.deskfree.ai";
+  const stage = process.env["STAGE"] ?? "dev";
+  return `https://${getStageDomain(stage, domain)}/v1/bot`;
+}
+function deriveWsUrl() {
+  const domain = process.env["DESKFREE_DOMAIN"] ?? "dev.deskfree.ai";
+  return `wss://ws.${domain}`;
 }
 function loadConfig() {
-  let botToken;
-  let apiUrl;
-  const launch = process.env["DESKFREE_LAUNCH"];
-  if (launch) {
-    try {
-      const decoded = JSON.parse(
-        Buffer.from(launch, "base64").toString("utf8")
-      );
-      botToken = decoded.botToken;
-      apiUrl = decoded.apiUrl;
-      if (!botToken || !apiUrl) {
-        throw new Error(
-          "Missing botToken or apiUrl in DESKFREE_LAUNCH payload"
-        );
-      }
-    } catch (err) {
-      if (err instanceof SyntaxError) {
-        throw new Error("DESKFREE_LAUNCH is not valid base64-encoded JSON");
-      }
-      throw err;
-    }
-  } else {
-    botToken = requireEnv("DESKFREE_BOT_TOKEN");
-    apiUrl = requireEnv("DESKFREE_API_URL");
+  const botId = process.env["BOT"] ?? process.env["DESKFREE_BOT_ID"];
+  if (!botId) {
+    throw new Error(
+      "Missing bot ID. Set the BOT environment variable (e.g. BOT=BFRH3VXHQR7)."
+    );
   }
-  const tokenError = validateBotToken(botToken);
-  if (tokenError !== null) {
-    throw new Error(`Invalid bot token: ${tokenError}`);
+  const idError = validateBotId(botId);
+  if (idError !== null) {
+    throw new Error(`Invalid bot ID: ${idError}`);
   }
+  const apiUrl = process.env["DESKFREE_API_URL"] ?? deriveApiUrl();
   const apiUrlError = validateApiUrl(apiUrl);
   if (apiUrlError !== null) {
     throw new Error(`Invalid API URL: ${apiUrlError}`);
@@ -8695,9 +8679,13 @@ function loadConfig() {
   if (isNaN(healthPort) || healthPort < 1 || healthPort > 65535) {
     throw new Error(`Invalid HEALTH_PORT: ${healthPortRaw}`);
   }
+  const stage = process.env["STAGE"] ?? "dev";
+  const wsUrl = process.env["DESKFREE_WS_URL"] ?? deriveWsUrl();
   return {
-    botToken,
+    botId,
     apiUrl,
+    stage,
+    wsUrl,
     stateDir: process.env["DESKFREE_STATE_DIR"] ?? DEFAULTS.stateDir,
     toolsDir: process.env["DESKFREE_TOOLS_DIR"] ?? DEFAULTS.toolsDir,
     logLevel,
@@ -8720,7 +8708,7 @@ function mergeWithRemoteConfig(local, remote) {
   return {
     ...local,
     claudeCodePath,
-    wsUrl: process.env["DESKFREE_WS_URL"] ?? remote.wsUrl,
+    wsUrl: process.env["DESKFREE_WS_URL"] ?? remote.wsUrl ?? local.wsUrl,
     model: process.env["DESKFREE_MODEL"] ?? remote.model,
     awsRegion: process.env["AWS_REGION"] ?? remote.awsRegion,
     heartbeatIntervalMs: process.env["DESKFREE_HEARTBEAT_INTERVAL_MS"] ? parseInt(process.env["DESKFREE_HEARTBEAT_INTERVAL_MS"], 10) : remote.heartbeatIntervalMs,
@@ -12573,17 +12561,43 @@ var require_websocket_server2 = __commonJS({
 });
 
 // ../../node_modules/ws/wrapper.mjs
-var import_websocket2, wrapper_default2;
+var wrapper_exports = {};
+__export(wrapper_exports, {
+  Receiver: () => import_receiver2.default,
+  Sender: () => import_sender2.default,
+  WebSocket: () => import_websocket2.default,
+  WebSocketServer: () => import_websocket_server2.default,
+  createWebSocketStream: () => import_stream2.default,
+  default: () => wrapper_default2
+});
+var import_stream2, import_receiver2, import_sender2, import_websocket2, import_websocket_server2, wrapper_default2;
 var init_wrapper = __esm({
   "../../node_modules/ws/wrapper.mjs"() {
-    __toESM(require_stream2());
-    __toESM(require_receiver2());
-    __toESM(require_sender2());
+    import_stream2 = __toESM(require_stream2());
+    import_receiver2 = __toESM(require_receiver2());
+    import_sender2 = __toESM(require_sender2());
     import_websocket2 = __toESM(require_websocket2());
-    __toESM(require_websocket_server2());
+    import_websocket_server2 = __toESM(require_websocket_server2());
     wrapper_default2 = import_websocket2.default;
   }
 });
+
+// src/gateway/ws-gateway.ts
+var ws_gateway_exports = {};
+__export(ws_gateway_exports, {
+  getRotationToken: () => getRotationToken,
+  setInitialRotationToken: () => setInitialRotationToken,
+  startGateway: () => startGateway
+});
+function getRotationToken() {
+  if (!currentRotationToken) {
+    throw new Error("No rotation token available \u2014 WS init not yet completed");
+  }
+  return currentRotationToken;
+}
+function setInitialRotationToken(token) {
+  currentRotationToken = token;
+}
 function nextBackoff(state2) {
   const delay = Math.min(
     BACKOFF_INITIAL_MS * Math.pow(BACKOFF_FACTOR, state2.attempt),
@@ -12609,6 +12623,89 @@ function sleepWithAbort(ms, signal) {
     signal.addEventListener("abort", onAbort, { once: true });
   });
 }
+async function wsReconnect(config, rotationToken) {
+  const { botId, stage, wsUrl, log, abortSignal } = config;
+  const params = new URLSearchParams({ id: botId, stage });
+  if (rotationToken) {
+    params.set("token", rotationToken);
+  }
+  const fullUrl = `${wsUrl}?${params.toString()}`;
+  return new Promise(
+    (resolve, reject) => {
+      const ws = new wrapper_default2(fullUrl);
+      let settled = false;
+      let timeoutTimer;
+      const cleanup = () => {
+        if (timeoutTimer !== void 0) {
+          clearTimeout(timeoutTimer);
+          timeoutTimer = void 0;
+        }
+      };
+      const fail = (err) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(err);
+      };
+      timeoutTimer = setTimeout(() => {
+        fail(
+          new Error(
+            `WS reconnect timeout after ${WS_RECONNECT_INIT_TIMEOUT_MS}ms`
+          )
+        );
+      }, WS_RECONNECT_INIT_TIMEOUT_MS);
+      ws.on("open", () => {
+        ws.send(JSON.stringify({ action: "init" }));
+      });
+      ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.action === "go" && msg.rotationToken) {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            resolve({ ws, rotationToken: msg.rotationToken });
+          } else if (msg.action === "rejected") {
+            fail(
+              new Error(
+                `Reconnect rejected: ${msg.reason ?? "unknown reason"}`
+              )
+            );
+          } else if (msg.action === "lobby") {
+            log.info("Reconnect landed in lobby \u2014 awaiting approval...");
+            cleanup();
+          }
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          log.warn(`Error parsing reconnect response: ${errMsg}`);
+        }
+      });
+      ws.on("error", (err) => {
+        fail(err instanceof Error ? err : new Error(String(err)));
+      });
+      ws.on("close", (code, reason) => {
+        if (!settled) {
+          fail(
+            new Error(
+              `WebSocket closed during reconnect: ${code} ${reason.toString()}`
+            )
+          );
+        }
+      });
+      abortSignal.addEventListener(
+        "abort",
+        () => {
+          fail(new Error("Aborted during WS reconnect"));
+        },
+        { once: true }
+      );
+    }
+  );
+}
 async function startGateway(config) {
   const { client, accountId, stateDir, log, abortSignal } = config;
   const ctx = { accountId };
@@ -12625,20 +12722,24 @@ async function startGateway(config) {
   });
   while (!abortSignal.aborted) {
     try {
-      const { ticket, wsUrl } = await client.getWsTicket();
-      resetBackoff(backoff);
-      if (totalReconnects > 0) {
+      let ws;
+      if (totalReconnects === 0) {
+        ws = config.initialWs;
+        currentRotationToken = config.initialRotationToken;
+        log.info("Using initial WS connection from handshake.");
+      } else {
         log.info(
-          `Got WS ticket, reconnecting to ${wsUrl}... (reconnect #${totalReconnects})`
+          `Reconnecting to ${config.wsUrl}... (reconnect #${totalReconnects})`
         );
+        const result = await wsReconnect(config, currentRotationToken ?? "");
+        ws = result.ws;
+        currentRotationToken = result.rotationToken;
         recordReconnect(accountId);
-      } else {
-        log.info(`Got WS ticket, connecting to ${wsUrl}...`);
       }
+      resetBackoff(backoff);
       updateHealthMode(accountId, "websocket");
       cursor = await runWebSocketConnection({
-        ticket,
-        wsUrl,
+        ws,
         client,
         accountId,
         stateDir,
@@ -12653,26 +12754,16 @@ async function startGateway(config) {
     } catch (err) {
       totalReconnects++;
       const message = err instanceof Error ? err.message : String(err);
-      if (message.includes("API error") || message.includes("authentication failed") || message.includes("server error")) {
+      const isConnectFailure = message.includes("WS-first connect") || message.includes("WS reconnect") || message.includes("Connection rejected") || message.includes("Reconnect rejected");
+      if (isConnectFailure) {
         log.warn(
-          `Ticket fetch failed (attempt #${totalReconnects}): ${message}. Falling back to polling.`
+          `Connection setup failed (attempt #${totalReconnects}): ${message}. Will retry after backoff.`
         );
-        reportError("error", `WS ticket fetch failed: ${message}`, {
+        reportError("error", `Connection setup failed: ${message}`, {
           component: "gateway",
-          event: "ticket_fetch_failed",
+          event: "ws_connect_failed",
           attempt: totalReconnects
         });
-        recordReconnect(accountId);
-        updateHealthMode(accountId, "polling");
-        cursor = await runPollingFallback({
-          client,
-          accountId,
-          stateDir,
-          cursor,
-          log,
-          abortSignal,
-          onMessage: config.onMessage
-        });
       } else {
         log.warn(`Connection error (attempt #${totalReconnects}): ${message}`);
         reportError("warn", `WS connection error: ${message}`, {
@@ -12680,8 +12771,8 @@ async function startGateway(config) {
           event: "connection_error",
           attempt: totalReconnects
         });
-        recordReconnect(accountId);
       }
+      recordReconnect(accountId);
       if (abortSignal.aborted) break;
       const delay = nextBackoff(backoff);
       log.info(
@@ -12693,25 +12784,20 @@ async function startGateway(config) {
   log.info(`Gateway loop exited after ${totalReconnects} reconnect(s).`);
 }
 async function runWebSocketConnection(opts) {
-  const { ticket, wsUrl, client, accountId, stateDir, log, abortSignal } = opts;
+  const { client, accountId, stateDir, log, abortSignal } = opts;
+  const ws = opts.ws;
   const ctx = { accountId };
   let cursor = opts.cursor;
   return new Promise((resolve, reject) => {
-    const ws = new wrapper_default2(`${wsUrl}?ticket=${ticket}`);
     let pingInterval;
-    let connectionTimer;
     let pongTimer;
     let notifyDebounceTimer;
-    let isConnected = false;
+    let proactiveReconnectTimer;
     const cleanup = () => {
       if (pingInterval !== void 0) {
         clearInterval(pingInterval);
         pingInterval = void 0;
       }
-      if (connectionTimer !== void 0) {
-        clearTimeout(connectionTimer);
-        connectionTimer = void 0;
-      }
       if (pongTimer !== void 0) {
         clearTimeout(pongTimer);
         pongTimer = void 0;
@@ -12720,78 +12806,72 @@ async function runWebSocketConnection(opts) {
         clearTimeout(notifyDebounceTimer);
         notifyDebounceTimer = void 0;
       }
+      if (proactiveReconnectTimer !== void 0) {
+        clearTimeout(proactiveReconnectTimer);
+        proactiveReconnectTimer = void 0;
+      }
     };
-    connectionTimer = setTimeout(() => {
-      if (!isConnected) {
-        cleanup();
+    setActiveWs(ws);
+    log.info("WebSocket session started.");
+    setWsConnected(true);
+    setHealthMode("websocket");
+    pingInterval = setInterval(() => {
+      if (ws.readyState === wrapper_default2.OPEN) {
         try {
-          ws.close();
-        } catch {
-        }
-        reject(
-          new Error(
-            `WebSocket connection timeout after ${WS_CONNECTION_TIMEOUT_MS}ms`
-          )
-        );
-      }
-    }, WS_CONNECTION_TIMEOUT_MS);
-    ws.on("open", () => {
-      isConnected = true;
-      setActiveWs(ws);
-      if (connectionTimer !== void 0) {
-        clearTimeout(connectionTimer);
-        connectionTimer = void 0;
-      }
-      log.info("WebSocket connected.");
-      setWsConnected(true);
-      setHealthMode("websocket");
-      pingInterval = setInterval(() => {
-        if (ws.readyState === wrapper_default2.OPEN) {
-          try {
-            ws.send(JSON.stringify({ action: "ping" }));
-            pongTimer = setTimeout(() => {
-              log.warn("Pong timeout \u2014 closing WebSocket");
-              try {
-                ws.close(1002, "pong timeout");
-              } catch {
-              }
-            }, WS_PONG_TIMEOUT_MS);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log.warn(`Failed to send ping: ${msg}`);
+          const pingPayload = { action: "ping" };
+          if (currentRotationToken) {
+            pingPayload.token = currentRotationToken;
           }
-        }
-      }, PING_INTERVAL_MS);
-      if (opts.getWorkerStatus) {
-        try {
-          const status2 = opts.getWorkerStatus();
-          ws.send(
-            JSON.stringify({
-              action: "heartbeatResponse",
-              ...status2
-            })
-          );
+          ws.send(JSON.stringify(pingPayload));
+          pongTimer = setTimeout(() => {
+            log.warn("Pong timeout \u2014 closing WebSocket");
+            try {
+              ws.close(1002, "pong timeout");
+            } catch {
+            }
+          }, WS_PONG_TIMEOUT_MS);
         } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          log.warn(`Failed to send initial heartbeat: ${errMsg}`);
+          const msg = err instanceof Error ? err.message : String(err);
+          log.warn(`Failed to send ping: ${msg}`);
         }
       }
-      void pollAndDeliver(
-        client,
-        accountId,
-        stateDir,
-        cursor,
-        opts.onMessage,
-        log
-      ).then((result) => {
-        if (result.cursor) {
-          cursor = result.cursor;
-          saveCursor(ctx, cursor, stateDir, log);
-        }
-      }).catch((err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        log.warn(`Initial poll failed: ${msg}`);
-      });
+    }, PING_INTERVAL_MS);
+    proactiveReconnectTimer = setTimeout(() => {
+      log.info("Proactive reconnect at 1h50m \u2014 closing for reconnect");
+      try {
+        ws.close(1e3, "proactive_reconnect");
+      } catch {
+      }
+    }, PROACTIVE_RECONNECT_MS);
+    if (opts.getWorkerStatus) {
+      try {
+        const status2 = opts.getWorkerStatus();
+        ws.send(
+          JSON.stringify({
+            action: "heartbeatResponse",
+            ...status2
+          })
+        );
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log.warn(`Failed to send initial heartbeat: ${errMsg}`);
+      }
+    }
+    void pollAndDeliver(
+      client,
+      accountId,
+      stateDir,
+      cursor,
+      opts.onMessage,
+      log
+    ).then((result) => {
+      if (result.cursor) {
+        cursor = result.cursor;
+        saveCursor(ctx, cursor, stateDir, log);
+      }
+    }).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.warn(`Initial poll failed: ${msg}`);
     });
     ws.on("message", (data) => {
       try {
@@ -12834,7 +12914,19 @@ async function runWebSocketConnection(opts) {
             clearTimeout(pongTimer);
             pongTimer = void 0;
           }
-          log.debug("Received pong \u2014 connection healthy");
+          const pongMsg = msg;
+          if (pongMsg.rotationToken) {
+            currentRotationToken = pongMsg.rotationToken;
+            log.debug("Received pong \u2014 token rotated");
+          } else if (pongMsg.error === "rotation_invalid") {
+            log.warn("Rotation token invalid \u2014 closing for reconnect");
+            try {
+              ws.close(1e3, "rotation_invalid");
+            } catch {
+            }
+          } else {
+            log.debug("Received pong \u2014 connection healthy");
+          }
         } else if (msg.action === "heartbeatRequest") {
           if (opts.getWorkerStatus && ws.readyState === wrapper_default2.OPEN) {
             try {
@@ -12936,7 +13028,6 @@ async function runWebSocketConnection(opts) {
     });
     ws.on("close", (code, reason) => {
       cleanup();
-      isConnected = false;
       setActiveWs(null);
       setWsConnected(false);
       if (code === 1e3 || code === 1001) {
@@ -12970,7 +13061,6 @@ async function runWebSocketConnection(opts) {
     });
     ws.on("error", (err) => {
       cleanup();
-      isConnected = false;
       setActiveWs(null);
       setWsConnected(false);
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -12999,50 +13089,7 @@ async function runWebSocketConnection(opts) {
     );
   });
 }
-async function runPollingFallback(opts) {
-  const { client, accountId, stateDir, log, abortSignal } = opts;
-  let cursor = opts.cursor;
-  let iterations = 0;
-  let consecutiveFailures = 0;
-  log.info("Running in polling fallback mode.");
-  setHealthMode("polling");
-  while (!abortSignal.aborted && iterations < MAX_POLLING_ITERATIONS) {
-    const result = await pollAndDeliver(
-      client,
-      accountId,
-      stateDir,
-      cursor,
-      opts.onMessage,
-      log
-    );
-    if (result.ok) {
-      if (result.cursor) cursor = result.cursor;
-      consecutiveFailures = 0;
-    } else {
-      consecutiveFailures++;
-      if (consecutiveFailures >= MAX_CONSECUTIVE_POLL_FAILURES) {
-        log.warn(
-          `${consecutiveFailures} consecutive poll failures, breaking to retry WebSocket`
-        );
-        reportError(
-          "error",
-          `${consecutiveFailures} consecutive poll failures, switching to WS retry`,
-          {
-            component: "gateway",
-            event: "poll_max_failures",
-            consecutiveFailures
-          }
-        );
-        break;
-      }
-    }
-    iterations++;
-    const jitter = Math.random() * POLL_FALLBACK_INTERVAL_MS * 0.2;
-    await sleepWithAbort(POLL_FALLBACK_INTERVAL_MS + jitter, abortSignal);
-  }
-  return cursor;
-}
-var PING_INTERVAL_MS, POLL_FALLBACK_INTERVAL_MS, WS_CONNECTION_TIMEOUT_MS, WS_PONG_TIMEOUT_MS, NOTIFY_DEBOUNCE_MS, HEALTH_LOG_INTERVAL_MS, MAX_POLLING_ITERATIONS, MAX_CONSECUTIVE_POLL_FAILURES, BACKOFF_INITIAL_MS, BACKOFF_MAX_MS, BACKOFF_FACTOR;
+var PING_INTERVAL_MS, WS_PONG_TIMEOUT_MS, NOTIFY_DEBOUNCE_MS, HEALTH_LOG_INTERVAL_MS, PROACTIVE_RECONNECT_MS, WS_RECONNECT_INIT_TIMEOUT_MS, BACKOFF_INITIAL_MS, BACKOFF_MAX_MS, BACKOFF_FACTOR, currentRotationToken;
 var init_ws_gateway = __esm({
   "src/gateway/ws-gateway.ts"() {
     init_health_state();
@@ -13051,16 +13098,15 @@ var init_ws_gateway = __esm({
     init_dist();
     init_wrapper();
     PING_INTERVAL_MS = 5 * 60 * 1e3;
-    POLL_FALLBACK_INTERVAL_MS = 3e4;
-    WS_CONNECTION_TIMEOUT_MS = 3e4;
     WS_PONG_TIMEOUT_MS = 1e4;
     NOTIFY_DEBOUNCE_MS = 200;
     HEALTH_LOG_INTERVAL_MS = 30 * 60 * 1e3;
-    MAX_POLLING_ITERATIONS = 10;
-    MAX_CONSECUTIVE_POLL_FAILURES = 5;
+    PROACTIVE_RECONNECT_MS = 110 * 60 * 1e3;
+    WS_RECONNECT_INIT_TIMEOUT_MS = 3e4;
     BACKOFF_INITIAL_MS = 2e3;
     BACKOFF_MAX_MS = 3e4;
     BACKOFF_FACTOR = 1.8;
+    currentRotationToken = null;
   }
 });
 function jsonSchemaPropertyToZod(prop) {
@@ -13274,13 +13320,13 @@ function validateDownloadUrl(url) {
   if (parsed.protocol !== "https:") {
     throw new Error("Only HTTPS URLs are allowed");
   }
-  const hostname = parsed.hostname.toLowerCase();
-  const bareHostname = hostname.replace(/^\[|\]$/g, "");
+  const hostname2 = parsed.hostname.toLowerCase();
+  const bareHostname = hostname2.replace(/^\[|\]$/g, "");
   if (bareHostname === "localhost" || bareHostname === "127.0.0.1" || bareHostname === "::1") {
     throw new Error("Local URLs are not allowed");
   }
   for (const pattern of PRIVATE_IPV4_PATTERNS) {
-    if (pattern.test(hostname)) {
+    if (pattern.test(hostname2)) {
       throw new Error("Private IP addresses are not allowed");
     }
   }
@@ -13850,8 +13896,9 @@ async function routeMessage(message, client, deps, sessionStore, config) {
           `Auto-reopening task ${message.taskId} (attachment on ${task.status} task)`
         );
         try {
-          await client.reopenTask({
+          await client.updateTaskStatus({
             taskId: message.taskId,
+            status: "open",
             reason: "Human sent an attachment \u2014 reopening for further work"
           });
           routingTarget = "orchestrator";
@@ -14603,6 +14650,17 @@ ${userMessage}
           } catch {
           }
         } finally {
+          try {
+            const task = await client.getTask({ taskId });
+            if (task.status === "open" && task.awaiting === "bot") {
+              log.info(
+                `Worker finished but task ${taskId} still awaiting bot \u2014 auto-flipping to human`
+              );
+              await client.updateTaskStatus({ taskId, awaiting: "human" });
+            }
+          } catch {
+            log.warn(`Failed to check/flip awaiting state for task ${taskId}`);
+          }
           const handle = this.workers.get(taskId);
           if (handle) {
             clearTimeout(handle.idleTimer);
@@ -14659,6 +14717,59 @@ ${userMessage}
   }
 });
 
+// src/auth/fingerprint.ts
+var fingerprint_exports = {};
+__export(fingerprint_exports, {
+  collectFingerprint: () => collectFingerprint
+});
+function collectFingerprint(stateDir, runtimeVersion) {
+  return {
+    hostId: getOrCreateHostId(stateDir),
+    machineId: getMachineId(),
+    platform: platform(),
+    arch: arch(),
+    hostname: hostname(),
+    cpuModel: cpus()[0]?.model ?? "unknown",
+    totalMemory: totalmem(),
+    nodeVersion: process.version,
+    runtimeVersion
+  };
+}
+function getOrCreateHostId(stateDir) {
+  const hostIdPath = join(stateDir, "host-id");
+  if (existsSync(hostIdPath)) {
+    const existing = readFileSync(hostIdPath, "utf8").trim();
+    if (existing) return existing;
+  }
+  const hostId = randomUUID();
+  mkdirSync(dirname(hostIdPath), { recursive: true });
+  writeFileSync(hostIdPath, hostId, "utf8");
+  return hostId;
+}
+function getMachineId() {
+  try {
+    if (platform() === "linux") {
+      if (existsSync("/etc/machine-id")) {
+        return readFileSync("/etc/machine-id", "utf8").trim();
+      }
+    }
+    if (platform() === "darwin") {
+      const output = execSync(
+        "ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID",
+        { encoding: "utf8", timeout: 5e3 }
+      );
+      const match = output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (match?.[1]) return match[1];
+    }
+  } catch {
+  }
+  return "unknown";
+}
+var init_fingerprint = __esm({
+  "src/auth/fingerprint.ts"() {
+  }
+});
+
 // src/service/entrypoint.ts
 var entrypoint_exports = {};
 __export(entrypoint_exports, {
@@ -14733,12 +14844,111 @@ function scheduleHeartbeat(createOrchServer, model, intervalMs, signal, log, cla
   setTimeout(() => void tick(), intervalMs);
   log.info(`Heartbeat scheduled every ${Math.round(intervalMs / 1e3)}s`);
 }
+async function initialConnect(opts) {
+  const { botId, stage, wsUrl, fingerprint, log, abortSignal } = opts;
+  const WebSocket2 = (await Promise.resolve().then(() => (init_wrapper(), wrapper_exports))).default;
+  const params = new URLSearchParams({ id: botId, stage });
+  const fullUrl = `${wsUrl}?${params.toString()}`;
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket2(fullUrl);
+    let settled = false;
+    let timeoutTimer;
+    const cleanup = () => {
+      if (timeoutTimer !== void 0) {
+        clearTimeout(timeoutTimer);
+        timeoutTimer = void 0;
+      }
+    };
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try {
+        ws.close();
+      } catch {
+      }
+      reject(err);
+    };
+    timeoutTimer = setTimeout(() => {
+      fail(new Error(`WS-first connect timeout after ${WS_INIT_TIMEOUT_MS}ms`));
+    }, WS_INIT_TIMEOUT_MS);
+    ws.on("open", () => {
+      const initMsg = { action: "init" };
+      {
+        initMsg.fingerprint = fingerprint;
+      }
+      ws.send(JSON.stringify(initMsg));
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.action === "go" && msg.rotationToken) {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          ws.removeAllListeners();
+          resolve({ ws, rotationToken: msg.rotationToken });
+        } else if (msg.action === "lobby") {
+          log.info("Awaiting human approval...");
+          cleanup();
+        } else if (msg.action === "rejected") {
+          fail(
+            new Error(`Connection rejected: ${msg.reason ?? "unknown reason"}`)
+          );
+        }
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log.warn(`Error parsing init response: ${errMsg}`);
+      }
+    });
+    ws.on("error", (err) => {
+      fail(err instanceof Error ? err : new Error(String(err)));
+    });
+    ws.on("close", (code, reason) => {
+      if (!settled) {
+        fail(
+          new Error(
+            `WebSocket closed during init: ${code} ${reason.toString()}`
+          )
+        );
+      }
+    });
+    abortSignal.addEventListener(
+      "abort",
+      () => {
+        fail(new Error("Aborted during WS-first connect"));
+      },
+      { once: true }
+    );
+  });
+}
 async function startAgent(opts) {
   const localConfig = loadConfig();
   const log = opts?.log ?? createLogger("agent", localConfig.logLevel);
   const abortController = new AbortController();
   log.info("DeskFree Agent Runtime starting...");
-  const client = new DeskFreeClient(localConfig.botToken, localConfig.apiUrl);
+  const { getRotationToken: getRotationToken2, setInitialRotationToken: setInitialRotationToken2 } = await Promise.resolve().then(() => (init_ws_gateway(), ws_gateway_exports));
+  const { collectFingerprint: collectFingerprint2 } = await Promise.resolve().then(() => (init_fingerprint(), fingerprint_exports));
+  const { createRequire } = await import('module');
+  const require3 = createRequire(import.meta.url);
+  const runtimePkg = require3("../../package.json");
+  const runtimeVersion = runtimePkg.version;
+  const fingerprint = collectFingerprint2(localConfig.stateDir, runtimeVersion);
+  log.info("Connecting to DeskFree...", { wsUrl: localConfig.wsUrl });
+  const connectResult = await initialConnect({
+    botId: localConfig.botId,
+    stage: localConfig.stage,
+    wsUrl: localConfig.wsUrl,
+    fingerprint,
+    log,
+    abortSignal: abortController.signal
+  });
+  setInitialRotationToken2(connectResult.rotationToken);
+  log.info("Connected \u2014 got rotation token via WS handshake.");
+  const client = new DeskFreeClient({
+    apiUrl: localConfig.apiUrl,
+    getToken: () => getRotationToken2()
+  });
   const errorReporter = initErrorReporter(client, log);
   initializeHealth("unknown");
   log.info("Bootstrapping from API...", { apiUrl: localConfig.apiUrl });
@@ -14758,7 +14968,6 @@ async function startAgent(opts) {
     throw new Error(`Failed to bootstrap config from API: ${msg}`);
   }
   const isDocker2 = process.env["DOCKER"] === "1" || (await import('fs')).existsSync("/.dockerenv");
-  const runtimeVersion = process.env["npm_package_version"] ?? "unknown";
   const agentContext = {
     botName: config.botName,
     deploymentType: config.deploymentType,
@@ -14830,7 +15039,7 @@ async function startAgent(opts) {
   const createOrchServer = () => createOrchestratorMcpServer(client, customTools, workerManager);
   const healthServer = startHealthServer(config.healthPort, log);
   const sessionStore = new SessionStore();
-  log.info("Starting gateway", { wsUrl: config.wsUrl, apiUrl: config.apiUrl });
+  log.info("Starting gateway", { wsUrl: config.wsUrl });
   void startGateway({
     client,
     wsUrl: config.wsUrl,
@@ -14838,6 +15047,10 @@ async function startAgent(opts) {
     stateDir: config.stateDir,
     log,
     abortSignal: abortController.signal,
+    botId: localConfig.botId,
+    stage: localConfig.stage,
+    initialWs: connectResult.ws,
+    initialRotationToken: connectResult.rotationToken,
     getWorkerStatus: () => ({
       activeWorkers: workerManager.activeCount,
       queuedTasks: workerManager.queuedCount,
@@ -14926,13 +15139,49 @@ async function startAgent(opts) {
         `Sleep cycle: invoking sleep agent (${orientResult.entries.length} unconsolidated entries)...`
       );
       const workerServer = createWorkServer();
-      const result = runOneShotWorker({
+      const agentStream = runOneShotWorker({
         prompt,
         systemPrompt: buildSleepDirective(agentContext),
         workerServer,
         model: config.model
       });
-      for await (const _ of result) {
+      let fullText = "";
+      for await (const msg of agentStream) {
+        if (msg.type === "assistant" && Array.isArray(msg.message?.content)) {
+          for (const block of msg.message.content) {
+            if (block.type === "text") {
+              fullText += block.text;
+            }
+          }
+        }
+      }
+      const tagMatch = fullText.match(
+        /<consolidation_result>([\s\S]*?)<\/consolidation_result>/
+      );
+      if (tagMatch) {
+        try {
+          const parsed = JSON.parse(tagMatch[1]);
+          const consolidateResult = await client.consolidateMemory({
+            newEntries: parsed.newEntries ?? [],
+            modifications: parsed.modifications ?? [],
+            operatingMemory: parsed.operatingMemory ?? ""
+          });
+          log.info(
+            `Sleep cycle: consolidation applied (${consolidateResult.opsApplied} ops, ${consolidateResult.entriesArchived} archived)`
+          );
+          if (consolidateResult.validationErrors?.length > 0) {
+            log.warn(
+              `Sleep cycle: validation errors: ${consolidateResult.validationErrors.join("; ")}`
+            );
+          }
+        } catch (parseErr) {
+          const parseMsg = parseErr instanceof Error ? parseErr.message : String(parseErr);
+          log.warn(`Sleep cycle: failed to submit consolidation: ${parseMsg}`);
+        }
+      } else {
+        log.warn(
+          "Sleep cycle: agent did not produce <consolidation_result> tags"
+        );
       }
       return "success";
     } finally {
@@ -15007,6 +15256,7 @@ async function startAgent(opts) {
     log.info("Shutdown complete.");
   };
 }
+var WS_INIT_TIMEOUT_MS;
 var init_entrypoint = __esm({
   "src/service/entrypoint.ts"() {
     init_orchestrator();
@@ -15023,6 +15273,7 @@ var init_entrypoint = __esm({
     init_sessions();
     init_worker_manager();
     init_dist();
+    WS_INIT_TIMEOUT_MS = 3e4;
   }
 });
 
@@ -15031,29 +15282,42 @@ init_paths();
 var [name, cleanArgs] = parseName(process.argv.slice(2));
 var command = cleanArgs[0];
 if (command === "install") {
-  let token = cleanArgs[1];
-  if (!token) {
+  const stageIdx = cleanArgs.indexOf("--stage");
+  let stage;
+  let installArgs = cleanArgs.slice(1);
+  if (stageIdx !== -1) {
+    stage = cleanArgs[stageIdx + 1];
+    if (!stage || stage.startsWith("-")) {
+      console.error("Error: --stage requires a value (e.g. --stage charlie)");
+      process.exit(1);
+    }
+    installArgs = installArgs.filter(
+      (_, i) => i !== stageIdx - 1 && i !== stageIdx
+    );
+  }
+  let botId = installArgs[0];
+  if (!botId) {
     const { createInterface } = await import('readline');
     const rl = createInterface({
       input: process.stdin,
       output: process.stdout
     });
-    token = await new Promise((resolve) => {
+    botId = await new Promise((resolve) => {
       rl.question(
-        "Paste your bot token (from the DeskFree dashboard):\n> ",
+        "Paste your bot ID (from the DeskFree dashboard):\n> ",
         (answer) => {
           rl.close();
           resolve(answer.trim());
         }
       );
     });
-    if (!token) {
-      console.error("No token provided.");
+    if (!botId) {
+      console.error("No bot ID provided.");
       process.exit(1);
     }
   }
   const { install: install2 } = await Promise.resolve().then(() => (init_install(), install_exports));
-  install2(token, name);
+  install2(botId, name, stage);
 } else if (command === "uninstall") {
   const { uninstall: uninstall2 } = await Promise.resolve().then(() => (init_uninstall(), uninstall_exports));
   uninstall2(name);
@@ -15079,14 +15343,12 @@ if (command === "install") {
       process.exit(1);
     }, 5e3).unref();
   };
-  let token;
-  if (command === "start") {
-    token = cleanArgs[1];
-  } else if (command && !command.startsWith("-")) {
-    token = command;
-  }
-  if (token && !process.env["DESKFREE_LAUNCH"]) {
-    process.env["DESKFREE_LAUNCH"] = token;
+  const startArgs = command === "start" ? cleanArgs.slice(1) : cleanArgs;
+  if (startArgs.length >= 2) {
+    process.env["STAGE"] = startArgs[0];
+    process.env["BOT"] = startArgs[1];
+  } else if (startArgs.length === 1) {
+    process.env["BOT"] = startArgs[0];
   }
   const { startAgent: startAgent2 } = await Promise.resolve().then(() => (init_entrypoint(), entrypoint_exports));
   const { createLogger: createLogger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));