@questionbase/deskfree 0.6.1 → 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';
@@ -109,7 +109,7 @@ var install_exports = {};
 __export(install_exports, {
   install: () => install
 });
-function installMac(token, name2) {
+function installMac(botId, name2, stage) {
   const paths = getMacPaths(name2);
   const plistLabel = getPlistLabel(name2);
   let nodeBinDir;
@@ -125,13 +125,9 @@ function installMac(token, name2) {
   mkdirSync(paths.deskfreeDir, { recursive: true });
   mkdirSync(paths.logDir, { recursive: true });
   mkdirSync(dirname(paths.plist), { recursive: true });
-  writeFileSync(
-    paths.envFile,
-    `DESKFREE_LAUNCH=${token}
-DESKFREE_INSTANCE_NAME=${name2}
-`,
-    { mode: 384 }
-  );
+  const envLines = [`BOT=${botId}`, `DESKFREE_INSTANCE_NAME=${name2}`];
+  if (stage) envLines.push(`STAGE=${stage}`);
+  writeFileSync(paths.envFile, envLines.join("\n") + "\n", { mode: 384 });
   chmodSync(paths.envFile, 384);
   console.log(`Wrote ${paths.envFile}`);
   const launcher = `#!/bin/bash
@@ -189,7 +185,7 @@ Service ${plistLabel} installed and started.`);
   console.log(`Check status: launchctl print gui/$(id -u)/${plistLabel}`);
   console.log(`Logs: tail -f ${join(paths.logDir, "stdout.log")}`);
 }
-function installLinux(token, name2) {
+function installLinux(botId, name2, stage) {
   if (process.getuid?.() !== 0) {
     console.error("Error: install must be run as root (use sudo)");
     process.exit(1);
@@ -220,13 +216,9 @@ function installLinux(token, name2) {
     `chown ${systemUser}:${systemUser} ${paths.stateDir} ${paths.logDir}`
   );
   console.log(`Created ${paths.stateDir} and ${paths.logDir}`);
-  writeFileSync(
-    paths.envFile,
-    `DESKFREE_LAUNCH=${token}
-DESKFREE_INSTANCE_NAME=${name2}
-`,
-    { mode: 384 }
-  );
+  const envLines = [`BOT=${botId}`, `DESKFREE_INSTANCE_NAME=${name2}`];
+  if (stage) envLines.push(`STAGE=${stage}`);
+  writeFileSync(paths.envFile, envLines.join("\n") + "\n", { mode: 384 });
   chmodSync(paths.envFile, 384);
   console.log(`Wrote ${paths.envFile}`);
   const unit = `[Unit]
@@ -264,11 +256,11 @@ Service ${serviceName} installed and started.`);
   console.log(`Check status: systemctl status ${serviceName}`);
   console.log(`Logs: tail -f ${paths.logDir}/stdout.log`);
 }
-function install(token, name2) {
+function install(botId, name2, stage) {
   if (process.platform === "darwin") {
-    installMac(token, name2);
+    installMac(botId, name2, stage);
   } else if (process.platform === "linux") {
-    installLinux(token, name2);
+    installLinux(botId, name2, stage);
   } else {
     console.error(`Unsupported platform: ${process.platform}`);
     process.exit(1);
@@ -2649,9 +2641,6 @@ function validateStringParam(params, key, required) {
 }
 function validateEnumParam(params, key, values, required) {
   const value = params?.[key];
-  if (required && (value === void 0 || value === null)) {
-    throw new Error(`Missing required parameter: ${key}`);
-  }
   if (value !== void 0 && value !== null && !values.includes(value)) {
     throw new Error(
       `Parameter ${key} must be one of: ${values.join(", ")}. Got: ${value}`
@@ -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);
@@ -2867,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" }]
         };
@@ -3025,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);
@@ -3099,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.`;
 }
@@ -3151,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.
@@ -3165,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:**
@@ -3540,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) {
@@ -7351,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}`;
@@ -7367,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,
@@ -7498,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) {
+      /** Update task status and/or awaiting state. */
+      async updateTaskStatus(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) {
-        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) {
@@ -7580,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
@@ -7922,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)"
             })
           )
         })
@@ -7938,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."
           }),
@@ -8072,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."
           }),
@@ -8229,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
     };
@@ -8276,7 +8298,7 @@ Record immediately when: the human corrects you, expresses a preference, shares
     DESKFREE_WORKER_DIRECTIVE = `## DeskFree \u2014 Task Thread
 You're in a task thread, focused on a specific piece of work. Same you as in the main thread \u2014 same voice, same personality.
 
-Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_orient, deskfree_complete_task, deskfree_send_message, deskfree_propose.
+Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_orient, deskfree_update_task_status, deskfree_send_message, deskfree_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.
@@ -8290,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:**
@@ -8644,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}`);
@@ -8696,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,
@@ -12584,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),
@@ -12609,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 };
@@ -12625,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(
@@ -12647,17 +12734,18 @@ async function startGateway(config) {
         abortSignal,
         onMessage: config.onMessage,
         getWorkerStatus: config.getWorkerStatus,
-        onConsolidate: config.onConsolidate
+        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
@@ -12702,6 +12790,7 @@ async function runWebSocketConnection(opts) {
     let connectionTimer;
     let pongTimer;
     let notifyDebounceTimer;
+    let proactiveReconnectTimer;
     let isConnected = false;
     const cleanup = () => {
       if (pingInterval !== void 0) {
@@ -12720,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) {
@@ -12748,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 {
@@ -12762,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();
@@ -12834,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 {
@@ -13042,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();
@@ -13058,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) {
@@ -13274,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");
     }
   }
@@ -13850,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";
@@ -14659,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, {
@@ -14733,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 });
@@ -14758,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,
@@ -14838,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,
@@ -14926,13 +15170,44 @@ async function startAgent(opts) {
         `Sleep cycle: invoking sleep agent (${orientResult.entries.length} unconsolidated entries)...`
       );
       const workerServer = createWorkServer();
-      const result = runOneShotWorker({
+      const agentStream = runOneShotWorker({
         prompt,
         systemPrompt: buildSleepDirective(agentContext),
         workerServer,
         model: config.model
       });
-      for await (const _ of result) {
+      let fullText = "";
+      for await (const msg of agentStream) {
+        if (msg.type === "assistant" && Array.isArray(msg.message?.content)) {
+          for (const block of msg.message.content) {
+            if (block.type === "text") {
+              fullText += block.text;
+            }
+          }
+        }
+      }
+      const tagMatch = fullText.match(
+        /<consolidation_result>([\s\S]*?)<\/consolidation_result>/
+      );
+      if (tagMatch) {
+        try {
+          const parsed = JSON.parse(tagMatch[1]);
+          const consolidateResult = await client.consolidateMemory({
+            newEntries: parsed.newEntries ?? [],
+            modifications: parsed.modifications ?? [],
+            operatingMemory: parsed.operatingMemory ?? ""
+          });
+          log.info(
+            `Sleep cycle: consolidation applied (${consolidateResult.opsApplied} ops, ${consolidateResult.entriesArchived} archived)`
+          );
+        } catch (parseErr) {
+          const parseMsg = parseErr instanceof Error ? parseErr.message : String(parseErr);
+          log.warn(`Sleep cycle: failed to submit consolidation: ${parseMsg}`);
+        }
+      } else {
+        log.warn(
+          "Sleep cycle: agent did not produce <consolidation_result> tags"
+        );
       }
       return "success";
     } finally {
@@ -15007,6 +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();
@@ -15023,6 +15299,7 @@ var init_entrypoint = __esm({
     init_sessions();
     init_worker_manager();
     init_dist();
+    CONNECT_POLL_INTERVAL_MS2 = 3e4;
   }
 });
 
@@ -15031,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);
@@ -15079,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));