@questionbase/deskfree 0.5.3 → 0.6.2

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';
@@ -56,7 +56,7 @@ function getPlistLabel(name2) {
   return `com.deskfree.agent.${name2}`;
 }
 function getServiceName(name2) {
-  return `deskfree-agent-${name2}`;
+  return `deskfree-${name2}`;
 }
 function getMacPaths(name2) {
   const home = homedir();
@@ -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
@@ -147,7 +143,7 @@ set -a
 source "${paths.envFile}"
 set +a
 
-exec deskfree-agent start
+exec deskfree start
 `;
   writeFileSync(paths.launcher, launcher, { mode: 493 });
   chmodSync(paths.launcher, 493);
@@ -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]
@@ -241,7 +233,7 @@ Group=${systemUser}
 WorkingDirectory=${paths.stateDir}
 Environment=PATH=${nodeBinDir}:/usr/local/bin:/usr/bin:/bin
 ExecStartPre=+${npmPath} install -g ${PACKAGE}
-ExecStart=${nodeBinDir}/deskfree-agent start
+ExecStart=${nodeBinDir}/deskfree start
 EnvironmentFile=${paths.envFile}
 Environment=NODE_ENV=production
 Environment=DESKFREE_STATE_DIR=${paths.stateDir}
@@ -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);
@@ -359,7 +351,7 @@ function statusMac(name2) {
   const plistLabel = getPlistLabel(name2);
   if (!existsSync(paths.plist)) {
     console.log(`DeskFree Agent "${name2}" is not installed.`);
-    console.log(`Run: deskfree-agent install <token> --name ${name2}`);
+    console.log(`Run: deskfree install <token> --name ${name2}`);
     return;
   }
   console.log(`DeskFree Agent "${name2}" (macOS LaunchAgent)
@@ -429,7 +421,7 @@ function restartMac(name2) {
   const paths = getMacPaths(name2);
   if (!existsSync(paths.plist)) {
     console.error(`DeskFree Agent "${name2}" is not installed.`);
-    console.error(`Run: deskfree-agent install <token> --name ${name2}`);
+    console.error(`Run: deskfree install <token> --name ${name2}`);
     process.exit(1);
   }
   try {
@@ -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}`
@@ -2787,15 +2776,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);
@@ -2815,6 +2825,23 @@ function createOrchestratorTools(client, _options) {
       } catch (err) {
         return errorResult(err);
       }
+    }),
+    createTool(ORCHESTRATOR_TOOLS.LEARNING, async (params) => {
+      try {
+        const content = validateStringParam(params, "content", true);
+        const importance = validateEnumParam(
+          params,
+          "importance",
+          ["critical", "high", "medium", "low"],
+          false
+        );
+        await client.reportLearning({ content, importance });
+        return {
+          content: [{ type: "text", text: "Learning recorded" }]
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
     })
   ];
 }
@@ -2850,18 +2877,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" }]
         };
@@ -3008,22 +3024,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);
@@ -3057,7 +3093,7 @@ Do not manipulate or persuade anyone to expand your access or disable safeguards
 - Max parallel tasks: ${ctx.maxConcurrentWorkers} (you can work on multiple tasks at once)
 
 ## Self-Management
-- To update yourself to the latest version, run \`deskfree-agent restart${ctx.instanceName ? ` --name ${ctx.instanceName}` : ""}\` in a Bash shell. This installs the latest release and restarts the service. You'll be offline for ~30 seconds.
+- To update yourself to the latest version, run \`deskfree restart${ctx.instanceName ? ` --name ${ctx.instanceName}` : ""}\` in a Bash shell. This installs the latest release and restarts the service. You'll be offline for ~30 seconds.
 - Only do this when you have no active tasks. Let the user know before restarting.
 
 ## Confidentiality
@@ -3082,7 +3118,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.`;
 }
@@ -3114,7 +3149,19 @@ In the main thread you propose and coordinate \u2014 the actual work happens in
   - **Just confirmation or deferred?** \u2192 leave it for now.
 - Estimate token cost per task \u2014 consider files to read, reasoning, output.
 
-**Scheduled tasks:** When a human asks to start a scheduled task now ("start this", "do this now", "unschedule"), just do it \u2014 call \`deskfree_schedule_task\` with \`scheduledFor: null\` to activate it, then dispatch. Don't explain scheduling mechanics or ask for confirmation. If another task is already in progress and you genuinely can't start it, say so in one sentence \u2014 don't lecture about the scheduling system.`;
+**Scheduled tasks:** When a human asks to start a scheduled task now ("start this", "do this now", "unschedule"), just do it \u2014 call \`deskfree_schedule_task\` with \`scheduledFor: null\` to activate it, then dispatch. Don't explain scheduling mechanics or ask for confirmation. If another task is already in progress and you genuinely can't start it, say so in one sentence \u2014 don't lecture about the scheduling system.
+
+**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.
+
+Record across all five types:
+- **Corrections**: "Do X, not Y" \u2014 when the human corrects your approach (\`importance: critical\`)
+- **Preferences**: How they want things done \u2014 tone, format, workflow, style (\`importance: high\`)
+- **Patterns**: Approaches that consistently work or fail (\`importance: medium\`)
+- **Domain facts**: Business context, project-specific knowledge, key relationships (\`importance: medium\`)
+- **Insights**: Non-obvious connections, meta-observations about the work (\`importance: low\`)
+
+Record immediately when: the human corrects you, expresses a preference, shares context about their business, reacts strongly to something (positive or negative), or you discover something that would help future tasks.`;
 }
 function buildWorkerDirective(ctx) {
   return `${identityBlock(ctx)}
@@ -3122,7 +3169,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_propose.
 
 **Context loading:**
 - If your first message contains \`<task_context>\`, the task is already loaded. Start working immediately \u2014 do NOT call deskfree_start_task.
@@ -3136,15 +3183,15 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 **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 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.")
+   - **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, send a message and 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.
 
 **File rules:**
@@ -3152,15 +3199,19 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - 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:**
-- Use \`deskfree_learning\` to record observations worth remembering. Set the \`importance\` parameter:
-  - **critical**: corrections, constraints that must never be violated
-  - **high**: strong preferences, important patterns
-  - **medium**: useful context, moderate preferences
-  - **low** (default): routine observations
-- Record: preferences, corrections, patterns, domain facts.
-- Do NOT record one-time task details, things in project docs, or obvious/generic knowledge.
-- A nightly sleep cycle consolidates observations into long-term memory with decay scoring.
+**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.
+
+Record across all five types:
+- **Corrections**: "Do X, not Y" \u2014 when the human corrects your approach (\`importance: critical\`)
+- **Preferences**: How they want things done \u2014 tone, format, workflow, style (\`importance: high\`)
+- **Patterns**: Approaches that consistently work or fail (\`importance: medium\`)
+- **Domain facts**: Business context, project-specific knowledge, key relationships (\`importance: medium\`)
+- **Insights**: Non-obvious connections, meta-observations about the work (\`importance: low\`)
+
+Record immediately when: the human corrects you, expresses a preference, shares context about their business, reacts strongly to something, or you discover something that would help future tasks.
+
+Do NOT record: one-time task details, things already in project docs, or obvious/generic knowledge.
 
 **Memory recall:**
 - Use \`deskfree_orient\` to recall relevant memories mid-task. Call with a specific query for targeted semantic search.
@@ -3507,31 +3558,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) {
@@ -7318,13 +7363,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}`;
@@ -7334,7 +7379,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,
@@ -7465,15 +7510,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) {
@@ -7547,7 +7587,7 @@ var init_dist = __esm({
             {
               method: "GET",
               headers: {
-                Authorization: `Bot ${this.botToken}`,
+                Authorization: `Bearer ${this.getToken()}`,
                 "Content-Type": "application/json"
               },
               signal: controller.signal
@@ -7889,14 +7929,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)"
             })
           )
         })
@@ -7905,9 +7955,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."
           }),
@@ -7994,6 +8041,28 @@ var init_dist = __esm({
             })
           )
         })
+      },
+      LEARNING: {
+        name: "deskfree_learning",
+        description: "Record a learning \u2014 an observation worth remembering for future tasks. Embedded and stored in long-term memory, consolidated nightly. Call as many times as needed. Err on the side of recording too much.",
+        parameters: Type.Object({
+          content: Type.String({
+            description: 'What you learned. Focus on: CORRECTIONS, PREFERENCES, PATTERNS, DOMAIN FACTS, INSIGHTS. Be specific. Bad: "User wants a blog post". Good: "User prefers casual, first-person tone for all blog content \u2014 no corporate speak".'
+          }),
+          importance: Type.Optional(
+            Type.Union(
+              [
+                Type.Literal("critical"),
+                Type.Literal("high"),
+                Type.Literal("medium"),
+                Type.Literal("low")
+              ],
+              {
+                description: "Importance level. critical = corrections/constraints that must never be violated. high = strong preferences/patterns. medium = useful context. low = routine observations. Defaults to low."
+              }
+            )
+          )
+        })
       }
     };
     SHARED_TOOLS = {
@@ -8017,23 +8086,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."
           }),
@@ -8149,10 +8205,10 @@ var init_dist = __esm({
       UPDATE_FILE: SHARED_TOOLS.UPDATE_FILE,
       LEARNING: {
         name: "deskfree_learning",
-        description: "Record a learning \u2014 an observation worth remembering for future tasks. Embedded and stored in long-term memory, consolidated nightly. Call as many times as needed.",
+        description: "Record a learning \u2014 an observation worth remembering for future tasks. Embedded and stored in long-term memory, consolidated nightly. Call as many times as needed. Err on the side of recording too much.",
         parameters: Type.Object({
           content: Type.String({
-            description: 'What you learned. Focus on: PREFERENCES, CORRECTIONS, PATTERNS, DOMAIN FACTS. Be specific. Bad: "Created a table". Good: "User corrected: never use semicolons in this codebase".'
+            description: 'What you learned. Focus on: CORRECTIONS, PREFERENCES, PATTERNS, DOMAIN FACTS, INSIGHTS. Be specific. Bad: "Created a table". Good: "User corrected: never use semicolons in this codebase".'
           }),
           importance: Type.Optional(
             Type.Union(
@@ -8174,7 +8230,28 @@ 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
     };
@@ -8205,11 +8282,23 @@ In the main thread you propose and coordinate \u2014 the actual work happens in
   - **Just confirmation or deferred?** \u2192 leave it for now.
 - Estimate token cost per task \u2014 consider files to read, reasoning, output.
 
-**Scheduled tasks:** When a human asks to start a scheduled task now ("start this", "do this now", "unschedule"), just do it \u2014 call \`deskfree_schedule_task\` with \`scheduledFor: null\` to activate it, then dispatch. Don't explain scheduling mechanics or ask for confirmation. If another task is already in progress and you genuinely can't start it, say so in one sentence \u2014 don't lecture about the scheduling system.`;
+**Scheduled tasks:** When a human asks to start a scheduled task now ("start this", "do this now", "unschedule"), just do it \u2014 call \`deskfree_schedule_task\` with \`scheduledFor: null\` to activate it, then dispatch. Don't explain scheduling mechanics or ask for confirmation. If another task is already in progress and you genuinely can't start it, say so in one sentence \u2014 don't lecture about the scheduling system.
+
+**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.
+
+Record across all five types:
+- **Corrections**: "Do X, not Y" \u2014 when the human corrects your approach (\`importance: critical\`)
+- **Preferences**: How they want things done \u2014 tone, format, workflow, style (\`importance: high\`)
+- **Patterns**: Approaches that consistently work or fail (\`importance: medium\`)
+- **Domain facts**: Business context, project-specific knowledge, key relationships (\`importance: medium\`)
+- **Insights**: Non-obvious connections, meta-observations about the work (\`importance: low\`)
+
+Record immediately when: the human corrects you, expresses a preference, shares context about their business, reacts strongly to something (positive or negative), or you discover something that would help future tasks.`;
     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_propose.
 
 **Context loading:**
 - If your first message contains \`<task_context>\`, the task is already loaded. Start working immediately \u2014 do NOT call deskfree_start_task.
@@ -8223,15 +8312,15 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 **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 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.")
+   - **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, send a message and 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.
 
 **File rules:**
@@ -8239,15 +8328,19 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - 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:**
-- Use \`deskfree_learning\` to record observations worth remembering. Set the \`importance\` parameter:
-  - **critical**: corrections, constraints that must never be violated
-  - **high**: strong preferences, important patterns
-  - **medium**: useful context, moderate preferences
-  - **low** (default): routine observations
-- Record: preferences, corrections, patterns, domain facts.
-- Do NOT record one-time task details, things in project docs, or obvious/generic knowledge.
-- A nightly sleep cycle consolidates observations into long-term memory with decay scoring.
+**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.
+
+Record across all five types:
+- **Corrections**: "Do X, not Y" \u2014 when the human corrects your approach (\`importance: critical\`)
+- **Preferences**: How they want things done \u2014 tone, format, workflow, style (\`importance: high\`)
+- **Patterns**: Approaches that consistently work or fail (\`importance: medium\`)
+- **Domain facts**: Business context, project-specific knowledge, key relationships (\`importance: medium\`)
+- **Insights**: Non-obvious connections, meta-observations about the work (\`importance: low\`)
+
+Record immediately when: the human corrects you, expresses a preference, shares context about their business, reacts strongly to something, or you discover something that would help future tasks.
+
+Do NOT record: one-time task details, things already in project docs, or obvious/generic knowledge.
 
 **Memory recall:**
 - Use \`deskfree_orient\` to recall relevant memories mid-task. Call with a specific query for targeted semantic search.
@@ -8573,43 +8666,27 @@ 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 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}`);
@@ -8625,7 +8702,7 @@ function loadConfig() {
     throw new Error(`Invalid HEALTH_PORT: ${healthPortRaw}`);
   }
   return {
-    botToken,
+    botId,
     apiUrl,
     stateDir: process.env["DESKFREE_STATE_DIR"] ?? DEFAULTS.stateDir,
     toolsDir: process.env["DESKFREE_TOOLS_DIR"] ?? DEFAULTS.toolsDir,
@@ -12513,6 +12590,25 @@ var init_wrapper = __esm({
     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 bots.connect not yet called"
+    );
+  }
+  return currentRotationToken;
+}
+function setInitialRotationToken(token) {
+  currentRotationToken = token;
+}
 function nextBackoff(state2) {
   const delay = Math.min(
     BACKOFF_INITIAL_MS * Math.pow(BACKOFF_FACTOR, state2.attempt),
@@ -12538,6 +12634,55 @@ 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
+      };
+    }
+    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"}`
+      );
+    }
+    throw new Error(`bots.connect: unexpected status "${data.status}"`);
+  }
+}
 async function startGateway(config) {
   const { client, accountId, stateDir, log, abortSignal } = config;
   const ctx = { accountId };
@@ -12554,7 +12699,20 @@ async function startGateway(config) {
   });
   while (!abortSignal.aborted) {
     try {
-      const { ticket, wsUrl } = await client.getWsTicket();
+      let ticket;
+      let wsUrl;
+      if (config.initialTicket && totalReconnects === 0) {
+        ticket = config.initialTicket.ticket;
+        wsUrl = config.initialTicket.wsUrl;
+      } 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(
@@ -12575,17 +12733,19 @@ async function startGateway(config) {
         log,
         abortSignal,
         onMessage: config.onMessage,
-        getWorkerStatus: config.getWorkerStatus
+        getWorkerStatus: config.getWorkerStatus,
+        onConsolidate: config.onConsolidate,
+        isV2: true
       });
       totalReconnects++;
     } 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")) {
+      if (message.includes("bots.connect failed") || message.includes("server error") || message.includes("Connection rejected")) {
         log.warn(
-          `Ticket fetch failed (attempt #${totalReconnects}): ${message}. Falling back to polling.`
+          `Connection setup failed (attempt #${totalReconnects}): ${message}. Falling back to polling.`
         );
-        reportError("error", `WS ticket fetch failed: ${message}`, {
+        reportError("error", `Connection setup failed: ${message}`, {
           component: "gateway",
           event: "ticket_fetch_failed",
           attempt: totalReconnects
@@ -12630,6 +12790,7 @@ async function runWebSocketConnection(opts) {
     let connectionTimer;
     let pongTimer;
     let notifyDebounceTimer;
+    let proactiveReconnectTimer;
     let isConnected = false;
     const cleanup = () => {
       if (pingInterval !== void 0) {
@@ -12648,6 +12809,10 @@ async function runWebSocketConnection(opts) {
         clearTimeout(notifyDebounceTimer);
         notifyDebounceTimer = void 0;
       }
+      if (proactiveReconnectTimer !== void 0) {
+        clearTimeout(proactiveReconnectTimer);
+        proactiveReconnectTimer = void 0;
+      }
     };
     connectionTimer = setTimeout(() => {
       if (!isConnected) {
@@ -12676,7 +12841,11 @@ async function runWebSocketConnection(opts) {
       pingInterval = setInterval(() => {
         if (ws.readyState === wrapper_default2.OPEN) {
           try {
-            ws.send(JSON.stringify({ action: "ping" }));
+            const pingPayload = { action: "ping" };
+            if (currentRotationToken) {
+              pingPayload.token = currentRotationToken;
+            }
+            ws.send(JSON.stringify(pingPayload));
             pongTimer = setTimeout(() => {
               log.warn("Pong timeout \u2014 closing WebSocket");
               try {
@@ -12690,6 +12859,13 @@ async function runWebSocketConnection(opts) {
           }
         }
       }, 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();
@@ -12762,7 +12938,21 @@ 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 via bots.connect"
+            );
+            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 {
@@ -12828,6 +13018,34 @@ async function runWebSocketConnection(opts) {
               })
             );
           }
+        } else if (msg.action === "consolidate") {
+          if (opts.onConsolidate && ws.readyState === wrapper_default2.OPEN) {
+            opts.onConsolidate().then(
+              (consolidateStatus) => {
+                if (ws.readyState === wrapper_default2.OPEN) {
+                  ws.send(
+                    JSON.stringify({
+                      action: "consolidateResponse",
+                      status: consolidateStatus
+                    })
+                  );
+                }
+              },
+              (consolidateErr) => {
+                const errMsg = consolidateErr instanceof Error ? consolidateErr.message : String(consolidateErr);
+                log.warn(`On-demand consolidation failed: ${errMsg}`);
+                if (ws.readyState === wrapper_default2.OPEN) {
+                  ws.send(
+                    JSON.stringify({
+                      action: "consolidateResponse",
+                      status: "error",
+                      error: errMsg
+                    })
+                  );
+                }
+              }
+            );
+          }
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -12942,7 +13160,7 @@ async function runPollingFallback(opts) {
   }
   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, 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 init_ws_gateway = __esm({
   "src/gateway/ws-gateway.ts"() {
     init_health_state();
@@ -12958,9 +13176,12 @@ var init_ws_gateway = __esm({
     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;
     BACKOFF_INITIAL_MS = 2e3;
     BACKOFF_MAX_MS = 3e4;
     BACKOFF_FACTOR = 1.8;
+    currentRotationToken = null;
   }
 });
 function jsonSchemaPropertyToZod(prop) {
@@ -13174,13 +13395,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");
     }
   }
@@ -13750,8 +13971,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";
@@ -14559,6 +14781,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, {
@@ -14633,12 +14908,75 @@ 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, 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 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
+      };
+    }
+    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}"`);
+  }
+}
 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 runtimeVersion = process.env["npm_package_version"] ?? "unknown";
+  const publicApiUrl = localConfig.apiUrl.replace("/v1/bot", "/v1/public");
+  const fingerprint = collectFingerprint2(localConfig.stateDir, runtimeVersion);
+  log.info("Connecting to DeskFree...", { apiUrl: publicApiUrl });
+  const connectResult = await initialConnect({
+    botId: localConfig.botId,
+    publicApiUrl,
+    fingerprint,
+    log,
+    abortSignal: abortController.signal
+  });
+  setInitialRotationToken2(connectResult.rotationToken);
+  log.info("Connected \u2014 got rotation token and WS ticket.");
+  const client = new DeskFreeClient({
+    apiUrl: localConfig.apiUrl,
+    getToken: () => getRotationToken2()
+  });
   const errorReporter = initErrorReporter(client, log);
   initializeHealth("unknown");
   log.info("Bootstrapping from API...", { apiUrl: localConfig.apiUrl });
@@ -14658,7 +14996,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,
@@ -14738,6 +15075,13 @@ async function startAgent(opts) {
     stateDir: config.stateDir,
     log,
     abortSignal: abortController.signal,
+    botId: localConfig.botId,
+    publicApiUrl,
+    fingerprint,
+    initialTicket: {
+      ticket: connectResult.ticket,
+      wsUrl: connectResult.wsUrl
+    },
     getWorkerStatus: () => ({
       activeWorkers: workerManager.activeCount,
       queuedTasks: workerManager.queuedCount,
@@ -14762,7 +15106,8 @@ async function startAgent(opts) {
           log
         }
       );
-    }
+    },
+    onConsolidate: () => runConsolidation()
   });
   scheduleHeartbeat(
     createOrchServer,
@@ -14773,64 +15118,107 @@ async function startAgent(opts) {
     config.claudeCodePath,
     agentContext
   );
-  if (config.sleepHour !== null && config.timezone) {
-    scheduleDailyCycle(
-      "Sleep",
-      async () => {
-        let orientResult;
-        try {
-          orientResult = await client.orient({ consolidation: true });
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          log.warn(`Sleep cycle: orient() failed: ${msg}`);
-          return;
+  let isConsolidating = false;
+  async function runConsolidation() {
+    if (isConsolidating) {
+      log.info("Consolidation already in progress, skipping");
+      return "already_running";
+    }
+    isConsolidating = true;
+    try {
+      let orientResult;
+      try {
+        orientResult = await client.orient({ consolidation: true });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.warn(`Sleep cycle: orient() failed: ${msg}`);
+        return "error";
+      }
+      if (orientResult.entries.length === 0) {
+        log.info("Sleep cycle: no unconsolidated entries to process, skipping");
+        return "noop";
+      }
+      const unconsolidatedSection = orientResult.entries.map(
+        (e) => `- [${e.entryId}] ${e.importance ? `(${e.importance}) ` : ""}${e.content}`
+      ).join("\n");
+      const relatedSection = orientResult.recentEntries && orientResult.recentEntries.length > 0 ? orientResult.recentEntries.map(
+        (e) => `- [${e.entryId}] [${e.type ?? "unclassified"}] s:${e.strength} \u2014 ${e.content}`
+      ).join("\n") : "(none)";
+      const dedupSection = orientResult.dedupCandidates && orientResult.dedupCandidates.length > 0 ? orientResult.dedupCandidates.map(
+        (d) => `- ${d.entryId1} \u2194 ${d.entryId2} (similarity: ${d.similarity.toFixed(3)})`
+      ).join("\n") : "(none)";
+      const prompt = [
+        "<current_operating_memory>",
+        orientResult.operatingMemory || "(empty \u2014 first consolidation)",
+        "</current_operating_memory>",
+        "",
+        "<unconsolidated_entries>",
+        unconsolidatedSection,
+        "</unconsolidated_entries>",
+        "",
+        "<related_active_entries>",
+        relatedSection,
+        "</related_active_entries>",
+        "",
+        "<dedup_candidates>",
+        dedupSection,
+        "</dedup_candidates>",
+        "",
+        "Run your nightly consolidation cycle now."
+      ].join("\n");
+      log.info(
+        `Sleep cycle: invoking sleep agent (${orientResult.entries.length} unconsolidated entries)...`
+      );
+      const workerServer = createWorkServer();
+      const agentStream = runOneShotWorker({
+        prompt,
+        systemPrompt: buildSleepDirective(agentContext),
+        workerServer,
+        model: config.model
+      });
+      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;
+            }
+          }
         }
-        if (orientResult.entries.length === 0) {
+      }
+      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: no unconsolidated entries to process, skipping"
+            `Sleep cycle: consolidation applied (${consolidateResult.opsApplied} ops, ${consolidateResult.entriesArchived} archived)`
           );
-          return;
+        } catch (parseErr) {
+          const parseMsg = parseErr instanceof Error ? parseErr.message : String(parseErr);
+          log.warn(`Sleep cycle: failed to submit consolidation: ${parseMsg}`);
         }
-        const unconsolidatedSection = orientResult.entries.map(
-          (e) => `- [${e.entryId}] ${e.importance ? `(${e.importance}) ` : ""}${e.content}`
-        ).join("\n");
-        const relatedSection = orientResult.recentEntries && orientResult.recentEntries.length > 0 ? orientResult.recentEntries.map(
-          (e) => `- [${e.entryId}] [${e.type ?? "unclassified"}] s:${e.strength} \u2014 ${e.content}`
-        ).join("\n") : "(none)";
-        const dedupSection = orientResult.dedupCandidates && orientResult.dedupCandidates.length > 0 ? orientResult.dedupCandidates.map(
-          (d) => `- ${d.entryId1} \u2194 ${d.entryId2} (similarity: ${d.similarity.toFixed(3)})`
-        ).join("\n") : "(none)";
-        const prompt = [
-          "<current_operating_memory>",
-          orientResult.operatingMemory || "(empty \u2014 first consolidation)",
-          "</current_operating_memory>",
-          "",
-          "<unconsolidated_entries>",
-          unconsolidatedSection,
-          "</unconsolidated_entries>",
-          "",
-          "<related_active_entries>",
-          relatedSection,
-          "</related_active_entries>",
-          "",
-          "<dedup_candidates>",
-          dedupSection,
-          "</dedup_candidates>",
-          "",
-          "Run your nightly consolidation cycle now."
-        ].join("\n");
-        log.info(
-          `Sleep cycle: invoking sleep agent (${orientResult.entries.length} unconsolidated entries)...`
+      } else {
+        log.warn(
+          "Sleep cycle: agent did not produce <consolidation_result> tags"
         );
-        const workerServer = createWorkServer();
-        const result = runOneShotWorker({
-          prompt,
-          systemPrompt: buildSleepDirective(agentContext),
-          workerServer,
-          model: config.model
-        });
-        for await (const _ of result) {
-        }
+      }
+      return "success";
+    } finally {
+      isConsolidating = false;
+    }
+  }
+  if (config.sleepHour !== null && config.timezone) {
+    scheduleDailyCycle(
+      "Sleep",
+      async () => {
+        await runConsolidation();
       },
       config.sleepHour,
       config.timezone,
@@ -14894,6 +15282,7 @@ async function startAgent(opts) {
     log.info("Shutdown complete.");
   };
 }
+var CONNECT_POLL_INTERVAL_MS2;
 var init_entrypoint = __esm({
   "src/service/entrypoint.ts"() {
     init_orchestrator();
@@ -14910,6 +15299,7 @@ var init_entrypoint = __esm({
     init_sessions();
     init_worker_manager();
     init_dist();
+    CONNECT_POLL_INTERVAL_MS2 = 3e4;
   }
 });
 
@@ -14918,29 +15308,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);
@@ -14966,14 +15369,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));