@questionbase/deskfree 0.6.2 → 0.6.3

package/dist/bin.js

@@ -2729,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})`
             }
           ]
         };
@@ -2974,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})`
             }
           ]
         };
@@ -3126,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.
 
@@ -3169,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_update_task_status, 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.
@@ -3180,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 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.")
+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 When work is ready for review, send a message and set \`awaiting: 'human'\` via \`deskfree_update_task_status\`. The human will complete the task when satisfied.
+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 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.
@@ -3235,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.
 
@@ -3250,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.
 
@@ -3266,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.
 
@@ -3353,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.
 
 ---
 
@@ -3393,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) {
@@ -7552,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.
@@ -7965,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: "Task ID to thread this proposal into (for follow-up proposals from within a task)"
+              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: "Parent task ID (for follow-up tasks created from within a task thread)"
             })
           )
         })
@@ -8100,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)"
             })
           )
         })
@@ -8253,32 +8221,32 @@ var init_dist = __esm({
         })
       },
       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.
 
@@ -8298,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_update_task_status, 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.
@@ -8309,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 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.")
+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 When work is ready for review, send a message and set \`awaiting: 'human'\` via \`deskfree_update_task_status\`. The human will complete the task when satisfied.
+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 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.
@@ -8675,6 +8649,10 @@ function deriveApiUrl() {
   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() {
   const botId = process.env["BOT"] ?? process.env["DESKFREE_BOT_ID"];
   if (!botId) {
@@ -8701,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 {
     botId,
     apiUrl,
+    stage,
+    wsUrl,
     stateDir: process.env["DESKFREE_STATE_DIR"] ?? DEFAULTS.stateDir,
     toolsDir: process.env["DESKFREE_TOOLS_DIR"] ?? DEFAULTS.toolsDir,
     logLevel,
@@ -8726,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,
@@ -12579,14 +12561,23 @@ 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;
   }
 });
@@ -12600,9 +12591,7 @@ __export(ws_gateway_exports, {
 });
 function getRotationToken() {
   if (!currentRotationToken) {
-    throw new Error(
-      "No rotation token available \u2014 bots.connect not yet called"
-    );
+    throw new Error("No rotation token available \u2014 WS init not yet completed");
   }
   return currentRotationToken;
 }
@@ -12634,54 +12623,88 @@ function sleepWithAbort(ms, signal) {
     signal.addEventListener("abort", onAbort, { once: true });
   });
 }
-async function callBotsConnect(config, rotationToken) {
-  const { botId, publicApiUrl, fingerprint, log, abortSignal } = config;
-  if (!botId || !publicApiUrl || !fingerprint) {
-    throw new Error(
-      "Gateway config missing botId, publicApiUrl, or fingerprint"
-    );
-  }
-  let connectToken;
-  while (true) {
-    if (abortSignal.aborted) throw new Error("Aborted during bots.connect");
-    const body = {
-      botId,
-      fingerprint,
-      ...rotationToken ? { rotationToken } : {},
-      ...connectToken ? { connectToken } : {}
-    };
-    const response = await fetch(`${publicApiUrl}/bots.connect`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new Error(`bots.connect failed: ${response.status} ${text}`);
-    }
-    const json = await response.json();
-    const data = json.result?.data;
-    if (!data) throw new Error("bots.connect: invalid response structure");
-    if (data.status === "approved") {
-      return {
-        ticket: data.ticket,
-        wsUrl: data.wsUrl,
-        rotationToken: data.rotationToken
+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;
+        }
       };
-    }
-    if (data.status === "awaiting_approval") {
-      connectToken = data.connectToken;
-      log.info("Awaiting human approval... polling in 30s");
-      await sleepWithAbort(CONNECT_POLL_INTERVAL_MS, abortSignal);
-      continue;
-    }
-    if (data.status === "rejected") {
-      throw new Error(
-        `Connection rejected: ${data.reason || "unknown reason"}`
+      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 }
       );
     }
-    throw new Error(`bots.connect: unexpected status "${data.status}"`);
-  }
+  );
 }
 async function startGateway(config) {
   const { client, accountId, stateDir, log, abortSignal } = config;
@@ -12699,33 +12722,24 @@ async function startGateway(config) {
   });
   while (!abortSignal.aborted) {
     try {
-      let ticket;
-      let wsUrl;
-      if (config.initialTicket && totalReconnects === 0) {
-        ticket = config.initialTicket.ticket;
-        wsUrl = config.initialTicket.wsUrl;
+      let ws;
+      if (totalReconnects === 0) {
+        ws = config.initialWs;
+        currentRotationToken = config.initialRotationToken;
+        log.info("Using initial WS connection from handshake.");
       } else {
-        const result = await callBotsConnect(
-          config,
-          currentRotationToken ?? void 0
-        );
-        ticket = result.ticket;
-        wsUrl = result.wsUrl;
-        currentRotationToken = result.rotationToken;
-      }
-      resetBackoff(backoff);
-      if (totalReconnects > 0) {
         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,
@@ -12734,33 +12748,22 @@ async function startGateway(config) {
         abortSignal,
         onMessage: config.onMessage,
         getWorkerStatus: config.getWorkerStatus,
-        onConsolidate: config.onConsolidate,
-        isV2: true
+        onConsolidate: config.onConsolidate
       });
       totalReconnects++;
     } catch (err) {
       totalReconnects++;
       const message = err instanceof Error ? err.message : String(err);
-      if (message.includes("bots.connect failed") || message.includes("server error") || message.includes("Connection rejected")) {
+      const isConnectFailure = message.includes("WS-first connect") || message.includes("WS reconnect") || message.includes("Connection rejected") || message.includes("Reconnect rejected");
+      if (isConnectFailure) {
         log.warn(
-          `Connection setup failed (attempt #${totalReconnects}): ${message}. Falling back to polling.`
+          `Connection setup failed (attempt #${totalReconnects}): ${message}. Will retry after backoff.`
         );
         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}`, {
@@ -12768,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(
@@ -12781,26 +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 proactiveReconnectTimer;
-    let isConnected = false;
     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;
@@ -12814,88 +12811,67 @@ async function runWebSocketConnection(opts) {
         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 {
-            const pingPayload = { action: "ping" };
-            if (currentRotationToken) {
-              pingPayload.token = currentRotationToken;
-            }
-            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 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);
-      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
-            })
-          );
+          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 {
@@ -12943,9 +12919,7 @@ async function runWebSocketConnection(opts) {
             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 via bots.connect"
-            );
+            log.warn("Rotation token invalid \u2014 closing for reconnect");
             try {
               ws.close(1e3, "rotation_invalid");
             } catch {
@@ -13054,7 +13028,6 @@ async function runWebSocketConnection(opts) {
     });
     ws.on("close", (code, reason) => {
       cleanup();
-      isConnected = false;
       setActiveWs(null);
       setWsConnected(false);
       if (code === 1e3 || code === 1001) {
@@ -13088,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);
@@ -13117,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, CONNECT_POLL_INTERVAL_MS, PROACTIVE_RECONNECT_MS, BACKOFF_INITIAL_MS, BACKOFF_MAX_MS, BACKOFF_FACTOR, currentRotationToken;
+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();
@@ -13169,15 +13098,11 @@ 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;
-    CONNECT_POLL_INTERVAL_MS = 3e4;
     PROACTIVE_RECONNECT_MS = 110 * 60 * 1e3;
+    WS_RECONNECT_INIT_TIMEOUT_MS = 3e4;
     BACKOFF_INITIAL_MS = 2e3;
     BACKOFF_MAX_MS = 3e4;
     BACKOFF_FACTOR = 1.8;
@@ -14725,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);
@@ -14909,49 +14845,82 @@ function scheduleHeartbeat(createOrchServer, model, intervalMs, signal, log, cla
   log.info(`Heartbeat scheduled every ${Math.round(intervalMs / 1e3)}s`);
 }
 async function initialConnect(opts) {
-  const { botId, publicApiUrl, fingerprint, log, abortSignal } = opts;
-  let connectToken;
-  while (true) {
-    if (abortSignal.aborted) throw new Error("Aborted during bots.connect");
-    const body = {
-      botId,
-      fingerprint,
-      ...connectToken ? { connectToken } : {}
+  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 response = await fetch(`${publicApiUrl}/bots.connect`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
+    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));
     });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new Error(`bots.connect failed: ${response.status} ${text}`);
-    }
-    const json = await response.json();
-    const data = json.result?.data;
-    if (!data) throw new Error("bots.connect: invalid response structure");
-    if (data.status === "approved") {
-      return {
-        ticket: data.ticket,
-        wsUrl: data.wsUrl,
-        rotationToken: data.rotationToken
-      };
-    }
-    if (data.status === "awaiting_approval") {
-      connectToken = data.connectToken;
-      log.info("Awaiting human approval... polling in 30s");
-      await new Promise(
-        (resolve) => setTimeout(resolve, CONNECT_POLL_INTERVAL_MS2)
-      );
-      continue;
-    }
-    if (data.status === "rejected") {
-      throw new Error(
-        `Connection rejected: ${data.reason || "unknown reason"}`
-      );
-    }
-    throw new Error(`bots.connect: unexpected status "${data.status}"`);
-  }
+    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();
@@ -14960,19 +14929,22 @@ async function startAgent(opts) {
   log.info("DeskFree Agent Runtime starting...");
   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 runtimeVersion = process.env["npm_package_version"] ?? "unknown";
-  const publicApiUrl = localConfig.apiUrl.replace("/v1/bot", "/v1/public");
+  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...", { apiUrl: publicApiUrl });
+  log.info("Connecting to DeskFree...", { wsUrl: localConfig.wsUrl });
   const connectResult = await initialConnect({
     botId: localConfig.botId,
-    publicApiUrl,
+    stage: localConfig.stage,
+    wsUrl: localConfig.wsUrl,
     fingerprint,
     log,
     abortSignal: abortController.signal
   });
   setInitialRotationToken2(connectResult.rotationToken);
-  log.info("Connected \u2014 got rotation token and WS ticket.");
+  log.info("Connected \u2014 got rotation token via WS handshake.");
   const client = new DeskFreeClient({
     apiUrl: localConfig.apiUrl,
     getToken: () => getRotationToken2()
@@ -15067,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,
@@ -15076,12 +15048,9 @@ async function startAgent(opts) {
     log,
     abortSignal: abortController.signal,
     botId: localConfig.botId,
-    publicApiUrl,
-    fingerprint,
-    initialTicket: {
-      ticket: connectResult.ticket,
-      wsUrl: connectResult.wsUrl
-    },
+    stage: localConfig.stage,
+    initialWs: connectResult.ws,
+    initialRotationToken: connectResult.rotationToken,
     getWorkerStatus: () => ({
       activeWorkers: workerManager.activeCount,
       queuedTasks: workerManager.queuedCount,
@@ -15200,6 +15169,11 @@ async function startAgent(opts) {
           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}`);
@@ -15282,7 +15256,7 @@ async function startAgent(opts) {
     log.info("Shutdown complete.");
   };
 }
-var CONNECT_POLL_INTERVAL_MS2;
+var WS_INIT_TIMEOUT_MS;
 var init_entrypoint = __esm({
   "src/service/entrypoint.ts"() {
     init_orchestrator();
@@ -15299,7 +15273,7 @@ var init_entrypoint = __esm({
     init_sessions();
     init_worker_manager();
     init_dist();
-    CONNECT_POLL_INTERVAL_MS2 = 3e4;
+    WS_INIT_TIMEOUT_MS = 3e4;
   }
 });