@questionbase/deskfree 0.4.5 → 0.5.0

package/dist/bin.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { execSync, execFileSync, execFile } from 'child_process';
-import { writeFileSync, chmodSync, existsSync, unlinkSync, mkdirSync, readdirSync, readFileSync, createWriteStream } from 'fs';
+import { spawn, execSync, execFileSync, execFile } from 'child_process';
+import { mkdirSync, writeFileSync, chmodSync, existsSync, unlinkSync, appendFileSync, readdirSync, readFileSync, statSync, createWriteStream } from 'fs';
+import { homedir } from 'os';
+import { dirname, join, extname } from 'path';
 import { createRequire as createRequire$1 } from 'module';
-import { join, dirname, extname } from 'path';
 import { query, createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
 import { appendFile, readFile, mkdir, unlink } from 'fs/promises';
@@ -57,22 +58,123 @@ var install_exports = {};
 __export(install_exports, {
   install: () => install
 });
-function install(token) {
+function getMacPaths() {
+  const home = homedir();
+  const deskfreeDir = join(home, ".deskfree");
+  return {
+    deskfreeDir,
+    envFile: join(deskfreeDir, ".env"),
+    launcher: join(deskfreeDir, "launcher.sh"),
+    logDir: join(deskfreeDir, "logs"),
+    plist: join(home, "Library", "LaunchAgents", `${PLIST_LABEL}.plist`)
+  };
+}
+function installMac(token) {
+  const paths = getMacPaths();
+  let nodeBinDir;
+  try {
+    const nodePath = execSync("which node", { encoding: "utf8" }).trim();
+    nodeBinDir = dirname(nodePath);
+  } catch {
+    console.error("Error: node not found in PATH");
+    process.exit(1);
+  }
+  mkdirSync(paths.deskfreeDir, { recursive: true });
+  mkdirSync(paths.logDir, { recursive: true });
+  mkdirSync(dirname(paths.plist), { recursive: true });
+  writeFileSync(paths.envFile, `DESKFREE_LAUNCH=${token}
+`, { mode: 384 });
+  chmodSync(paths.envFile, 384);
+  console.log(`Wrote ${paths.envFile}`);
+  const launcher = `#!/bin/bash
+set -euo pipefail
+
+export PATH="${nodeBinDir}:$PATH"
+
+# Update to latest version before starting
+npm install -g ${PACKAGE} 2>/dev/null || true
+
+# Source env
+set -a
+source "${paths.envFile}"
+set +a
+
+exec deskfree-agent start
+`;
+  writeFileSync(paths.launcher, launcher, { mode: 493 });
+  chmodSync(paths.launcher, 493);
+  console.log(`Wrote ${paths.launcher}`);
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${paths.launcher}</string>
+  </array>
+  <key>KeepAlive</key>
+  <true/>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(paths.logDir, "stdout.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(paths.logDir, "stderr.log")}</string>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+</dict>
+</plist>
+`;
+  writeFileSync(paths.plist, plist);
+  console.log(`Wrote ${paths.plist}`);
+  try {
+    execSync(`launchctl bootout gui/$(id -u) ${paths.plist}`, {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  execSync(`launchctl bootstrap gui/$(id -u) ${paths.plist}`);
+  console.log(`
+Service ${PLIST_LABEL} installed and started.`);
+  console.log(`Check status: launchctl print gui/$(id -u)/${PLIST_LABEL}`);
+  console.log(`Logs: tail -f ${join(paths.logDir, "stdout.log")}`);
+}
+function installLinux(token) {
   if (process.getuid?.() !== 0) {
     console.error("Error: install must be run as root (use sudo)");
     process.exit(1);
   }
-  let npxPath;
+  let npmPath;
+  let nodeBinDir;
   try {
-    npxPath = execSync("which npx", { encoding: "utf8" }).trim();
+    npmPath = execSync("which npm", { encoding: "utf8" }).trim();
+    nodeBinDir = dirname(npmPath);
   } catch {
-    console.error("Error: npx not found in PATH");
+    console.error("Error: npm not found in PATH");
     process.exit(1);
   }
-  writeFileSync(ENV_FILE, `DESKFREE_LAUNCH=${token}
-`, { mode: 384 });
-  chmodSync(ENV_FILE, 384);
-  console.log(`Wrote ${ENV_FILE}`);
+  try {
+    execSync("id deskfree-agent", { stdio: "ignore" });
+  } catch {
+    execSync(
+      "useradd --system --no-create-home --shell /usr/sbin/nologin deskfree-agent"
+    );
+    console.log("Created system user: deskfree-agent");
+  }
+  mkdirSync(LINUX_STATE_DIR, { recursive: true });
+  mkdirSync(LINUX_LOG_DIR, { recursive: true });
+  execSync(
+    `chown deskfree-agent:deskfree-agent ${LINUX_STATE_DIR} ${LINUX_LOG_DIR}`
+  );
+  console.log(`Created ${LINUX_STATE_DIR} and ${LINUX_LOG_DIR}`);
+  writeFileSync(SYSTEMD_ENV_FILE, `DESKFREE_LAUNCH=${token}
+`, {
+    mode: 384
+  });
+  chmodSync(SYSTEMD_ENV_FILE, 384);
+  console.log(`Wrote ${SYSTEMD_ENV_FILE}`);
   const unit = `[Unit]
 Description=DeskFree Agent
 After=network-online.target
@@ -80,30 +182,54 @@ Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStart=${npxPath} ${PACKAGE} start
-EnvironmentFile=${ENV_FILE}
+User=deskfree-agent
+Group=deskfree-agent
+WorkingDirectory=${LINUX_STATE_DIR}
+Environment=PATH=${nodeBinDir}:/usr/local/bin:/usr/bin:/bin
+ExecStartPre=+${npmPath} install -g ${PACKAGE}
+ExecStart=${nodeBinDir}/deskfree-agent start
+EnvironmentFile=${SYSTEMD_ENV_FILE}
 Environment=NODE_ENV=production
+Environment=DESKFREE_STATE_DIR=${LINUX_STATE_DIR}
+Environment=DESKFREE_TOOLS_DIR=${LINUX_STATE_DIR}/tools
 Restart=always
 RestartSec=10
+StandardOutput=append:${LINUX_LOG_DIR}/stdout.log
+StandardError=append:${LINUX_LOG_DIR}/stderr.log
 
 [Install]
 WantedBy=multi-user.target
 `;
-  writeFileSync(SERVICE_FILE, unit);
-  console.log(`Wrote ${SERVICE_FILE}`);
+  writeFileSync(SYSTEMD_SERVICE_FILE, unit);
+  console.log(`Wrote ${SYSTEMD_SERVICE_FILE}`);
   execSync("systemctl daemon-reload");
   execSync(`systemctl enable ${SERVICE_NAME}`);
   execSync(`systemctl start ${SERVICE_NAME}`);
-  console.log(`Service ${SERVICE_NAME} installed and started.`);
+  console.log(`
+Service ${SERVICE_NAME} installed and started.`);
   console.log(`Check status: systemctl status ${SERVICE_NAME}`);
+  console.log(`Logs: tail -f ${LINUX_LOG_DIR}/stdout.log`);
 }
-var SERVICE_NAME, SERVICE_FILE, ENV_FILE, PACKAGE;
+function install(token) {
+  if (process.platform === "darwin") {
+    installMac(token);
+  } else if (process.platform === "linux") {
+    installLinux(token);
+  } else {
+    console.error(`Unsupported platform: ${process.platform}`);
+    process.exit(1);
+  }
+}
+var SERVICE_NAME, PACKAGE, PLIST_LABEL, SYSTEMD_SERVICE_FILE, SYSTEMD_ENV_FILE, LINUX_STATE_DIR, LINUX_LOG_DIR;
 var init_install = __esm({
   "src/cli/install.ts"() {
     SERVICE_NAME = "deskfree-agent";
-    SERVICE_FILE = `/etc/systemd/system/${SERVICE_NAME}.service`;
-    ENV_FILE = `/etc/${SERVICE_NAME}.env`;
     PACKAGE = "@questionbase/deskfree@latest";
+    PLIST_LABEL = "com.deskfree.agent";
+    SYSTEMD_SERVICE_FILE = `/etc/systemd/system/${SERVICE_NAME}.service`;
+    SYSTEMD_ENV_FILE = `/etc/${SERVICE_NAME}.env`;
+    LINUX_STATE_DIR = "/var/lib/deskfree-agent";
+    LINUX_LOG_DIR = "/var/log/deskfree-agent";
   }
 });
 
@@ -112,7 +238,28 @@ var uninstall_exports = {};
 __export(uninstall_exports, {
   uninstall: () => uninstall
 });
-function uninstall() {
+function uninstallMac() {
+  const home = homedir();
+  const plist = join(home, "Library", "LaunchAgents", `${PLIST_LABEL2}.plist`);
+  const deskfreeDir = join(home, ".deskfree");
+  const envFile = join(deskfreeDir, ".env");
+  const launcher = join(deskfreeDir, "launcher.sh");
+  try {
+    execSync(`launchctl bootout gui/$(id -u) ${plist}`, { stdio: "ignore" });
+  } catch {
+  }
+  for (const file of [plist, envFile, launcher]) {
+    if (existsSync(file)) {
+      unlinkSync(file);
+      console.log(`Removed ${file}`);
+    }
+  }
+  console.log(`Service ${PLIST_LABEL2} uninstalled.`);
+  console.log(
+    `Note: logs and state in ${deskfreeDir} were preserved. Remove manually if desired.`
+  );
+}
+function uninstallLinux() {
   if (process.getuid?.() !== 0) {
     console.error("Error: uninstall must be run as root (use sudo)");
     process.exit(1);
@@ -125,23 +272,203 @@ function uninstall() {
     execSync(`systemctl disable ${SERVICE_NAME2}`, { stdio: "ignore" });
   } catch {
   }
-  if (existsSync(SERVICE_FILE2)) {
-    unlinkSync(SERVICE_FILE2);
-    console.log(`Removed ${SERVICE_FILE2}`);
+  if (existsSync(SYSTEMD_SERVICE_FILE2)) {
+    unlinkSync(SYSTEMD_SERVICE_FILE2);
+    console.log(`Removed ${SYSTEMD_SERVICE_FILE2}`);
   }
-  if (existsSync(ENV_FILE2)) {
-    unlinkSync(ENV_FILE2);
-    console.log(`Removed ${ENV_FILE2}`);
+  if (existsSync(SYSTEMD_ENV_FILE2)) {
+    unlinkSync(SYSTEMD_ENV_FILE2);
+    console.log(`Removed ${SYSTEMD_ENV_FILE2}`);
   }
   execSync("systemctl daemon-reload");
   console.log(`Service ${SERVICE_NAME2} uninstalled.`);
 }
-var SERVICE_NAME2, SERVICE_FILE2, ENV_FILE2;
+function uninstall() {
+  if (process.platform === "darwin") {
+    uninstallMac();
+  } else if (process.platform === "linux") {
+    uninstallLinux();
+  } else {
+    console.error(`Unsupported platform: ${process.platform}`);
+    process.exit(1);
+  }
+}
+var SERVICE_NAME2, PLIST_LABEL2, SYSTEMD_SERVICE_FILE2, SYSTEMD_ENV_FILE2;
 var init_uninstall = __esm({
   "src/cli/uninstall.ts"() {
     SERVICE_NAME2 = "deskfree-agent";
-    SERVICE_FILE2 = `/etc/systemd/system/${SERVICE_NAME2}.service`;
-    ENV_FILE2 = `/etc/${SERVICE_NAME2}.env`;
+    PLIST_LABEL2 = "com.deskfree.agent";
+    SYSTEMD_SERVICE_FILE2 = `/etc/systemd/system/${SERVICE_NAME2}.service`;
+    SYSTEMD_ENV_FILE2 = `/etc/${SERVICE_NAME2}.env`;
+  }
+});
+
+// src/cli/status.ts
+var status_exports = {};
+__export(status_exports, {
+  status: () => status
+});
+function statusMac() {
+  const home = homedir();
+  const plist = join(home, "Library", "LaunchAgents", `${PLIST_LABEL3}.plist`);
+  if (!existsSync(plist)) {
+    console.log("DeskFree Agent is not installed.");
+    console.log(`Run: curl -fsSL https://my.deskfree.ai/install.sh | bash`);
+    return;
+  }
+  console.log("DeskFree Agent (macOS LaunchAgent)\n");
+  try {
+    const output = execSync(
+      `launchctl print gui/$(id -u)/${PLIST_LABEL3} 2>&1`,
+      { encoding: "utf8" }
+    );
+    const pidMatch = output.match(/pid\s*=\s*(\d+)/);
+    const stateMatch = output.match(/state\s*=\s*(\w+)/);
+    if (pidMatch) console.log(`  PID: ${pidMatch[1]}`);
+    if (stateMatch) console.log(`  State: ${stateMatch[1]}`);
+    const logDir = join(home, ".deskfree", "logs");
+    console.log(`  Logs: ${logDir}/stdout.log`);
+    console.log(`  Plist: ${plist}`);
+  } catch {
+    console.log("  Status: not running (service may be unloaded)");
+  }
+}
+function statusLinux() {
+  const serviceFile = `/etc/systemd/system/${SYSTEMD_SERVICE_NAME}.service`;
+  if (!existsSync(serviceFile)) {
+    console.log("DeskFree Agent is not installed.");
+    console.log(`Run: sudo npx @questionbase/deskfree@latest install <token>`);
+    return;
+  }
+  console.log("DeskFree Agent (systemd service)\n");
+  try {
+    const output = execSync(
+      `systemctl status ${SYSTEMD_SERVICE_NAME} --no-pager 2>&1`,
+      { encoding: "utf8" }
+    );
+    console.log(output);
+  } catch (err) {
+    if (err && typeof err === "object" && "stdout" in err) {
+      console.log(err.stdout);
+    } else {
+      console.log("  Status: unknown (could not query systemd)");
+    }
+  }
+  console.log(`  Logs: /var/log/deskfree-agent/stdout.log`);
+}
+function status() {
+  if (process.platform === "darwin") {
+    statusMac();
+  } else if (process.platform === "linux") {
+    statusLinux();
+  } else {
+    console.error(`Unsupported platform: ${process.platform}`);
+    process.exit(1);
+  }
+}
+var PLIST_LABEL3, SYSTEMD_SERVICE_NAME;
+var init_status = __esm({
+  "src/cli/status.ts"() {
+    PLIST_LABEL3 = "com.deskfree.agent";
+    SYSTEMD_SERVICE_NAME = "deskfree-agent";
+  }
+});
+
+// src/cli/restart.ts
+var restart_exports = {};
+__export(restart_exports, {
+  restart: () => restart
+});
+function restartMac() {
+  const plist = join(
+    homedir(),
+    "Library",
+    "LaunchAgents",
+    `${PLIST_LABEL4}.plist`
+  );
+  if (!existsSync(plist)) {
+    console.error("DeskFree Agent is not installed.");
+    console.error("Run: curl -fsSL https://my.deskfree.ai/install.sh | bash");
+    process.exit(1);
+  }
+  try {
+    execSync(`launchctl bootout gui/$(id -u) ${plist}`, { stdio: "ignore" });
+  } catch {
+  }
+  execSync(`launchctl bootstrap gui/$(id -u) ${plist}`);
+  console.log("DeskFree Agent restarted.");
+  console.log(
+    `Logs: tail -f ${join(homedir(), ".deskfree", "logs", "stdout.log")}`
+  );
+}
+function restartLinux() {
+  const serviceFile = `/etc/systemd/system/${SYSTEMD_SERVICE_NAME2}.service`;
+  if (!existsSync(serviceFile)) {
+    console.error("DeskFree Agent is not installed.");
+    console.error(
+      "Run: sudo npx @questionbase/deskfree@latest install <token>"
+    );
+    process.exit(1);
+  }
+  execSync(`systemctl restart ${SYSTEMD_SERVICE_NAME2}`, { stdio: "inherit" });
+  console.log("DeskFree Agent restarted.");
+  console.log(`Logs: tail -f /var/log/deskfree-agent/stdout.log`);
+}
+function restart() {
+  if (process.platform === "darwin") {
+    restartMac();
+  } else if (process.platform === "linux") {
+    restartLinux();
+  } else {
+    console.error(`Unsupported platform: ${process.platform}`);
+    process.exit(1);
+  }
+}
+var PLIST_LABEL4, SYSTEMD_SERVICE_NAME2;
+var init_restart = __esm({
+  "src/cli/restart.ts"() {
+    PLIST_LABEL4 = "com.deskfree.agent";
+    SYSTEMD_SERVICE_NAME2 = "deskfree-agent";
+  }
+});
+
+// src/cli/logs.ts
+var logs_exports = {};
+__export(logs_exports, {
+  logs: () => logs
+});
+function getLogPath() {
+  if (process.platform === "darwin") {
+    const logFile = join(homedir(), ".deskfree", "logs", "stdout.log");
+    return existsSync(logFile) ? logFile : null;
+  } else if (process.platform === "linux") {
+    const logFile = "/var/log/deskfree-agent/stdout.log";
+    return existsSync(logFile) ? logFile : null;
+  }
+  return null;
+}
+function logs(follow) {
+  if (process.platform !== "darwin" && process.platform !== "linux") {
+    console.error(`Unsupported platform: ${process.platform}`);
+    process.exit(1);
+  }
+  const logPath = getLogPath();
+  if (!logPath) {
+    console.error("No log file found. Is DeskFree Agent installed?");
+    process.exit(1);
+  }
+  const args2 = follow ? ["-f", "-n", "50", logPath] : ["-n", "50", logPath];
+  const child = spawn("tail", args2, { stdio: "inherit" });
+  child.on("error", (err) => {
+    console.error(`Failed to read logs: ${err.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+var init_logs = __esm({
+  "src/cli/logs.ts"() {
   }
 });
 function toErrorMessage(error) {
@@ -2554,6 +2881,41 @@ function createWorkerTools(client, options) {
         return errorResult(err);
       }
     }),
+    createTool(WORKER_TOOLS.PROPOSE, async (params) => {
+      try {
+        const context = validateStringParam(params, "context", false);
+        const taskId = validateStringParam(params, "taskId", false);
+        const rawTasks = params.tasks;
+        if (!Array.isArray(rawTasks) || rawTasks.length === 0) {
+          throw new Error("tasks must be a non-empty array of task objects");
+        }
+        const tasks = rawTasks;
+        for (let i = 0; i < tasks.length; i++) {
+          const task = tasks[i];
+          if (!task || typeof task !== "object") {
+            throw new Error(`tasks[${i}] must be an object`);
+          }
+          if (!task.title || typeof task.title !== "string" || task.title.trim() === "") {
+            throw new Error(`tasks[${i}].title must be a non-empty string`);
+          }
+        }
+        await client.proposePlan({
+          context,
+          tasks,
+          taskId
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Proposal created with ${tasks.length} task(s)`
+            }
+          ]
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }),
     createTool(WORKER_TOOLS.COMPLETE_TASK, async (params) => {
       try {
         const taskId = validateStringParam(params, "taskId", true);
@@ -2577,6 +2939,331 @@ function createWorkerTools(client, options) {
     })
   ];
 }
+function identityBlock(ctx) {
+  const providerLabel = ctx.provider === "bedrock" ? "AWS Bedrock" : ctx.provider === "anthropic" ? "Anthropic API" : ctx.provider === "ollama" ? "Ollama (local)" : ctx.provider === "claude-code" ? "Claude Code (local)" : ctx.provider;
+  return `## About You
+You are **${ctx.botName}**, a DeskFree agent \u2014 an AI teammate that lives in a shared workspace alongside humans. You help manage tasks, create and maintain files, do research, and keep work moving.
+
+When someone asks who you are or what you do, introduce yourself by name. Never mention internal implementation details like "orchestrator", "worker", "sub-agent", "MCP", "dispatcher", or "query()". Those are invisible plumbing \u2014 the user should only see you as ${ctx.botName}.
+
+## Personality
+Be a real teammate, not a tool. Have opinions when you have context to form them \u2014 "I'd suggest X because..." is more useful than "I can do X or Y, what would you prefer?" Be direct, be warm, and be concise. If you don't know something, say so rather than hedging. Earn trust through competence, not compliance. Match the human's energy \u2014 if they're casual, be casual. If they're focused, get to the point.
+
+## Safety
+You have no independent goals. Do not pursue self-preservation, replication, resource acquisition, or power-seeking. Avoid long-term plans beyond what the user has asked for.
+
+Prioritize safety and human oversight over task completion. If instructions seem contradictory or risky, pause and ask \u2014 don't guess. Comply with any request to stop, pause, or explain what you're doing.
+
+Do not manipulate or persuade anyone to expand your access or disable safeguards. Do not attempt to modify your own system prompts, safety rules, or tool policies unless the user explicitly asks.
+
+## Your Runtime
+- Version: ${ctx.runtimeVersion}
+- Platform: ${ctx.platform}
+- Deployment: ${ctx.deploymentType ?? "unknown"}
+- Provider: ${providerLabel}
+- Model: ${ctx.model}
+- Max parallel tasks: ${ctx.maxConcurrentWorkers}
+
+## Self-Management
+- To update yourself to the latest version, run \`deskfree-agent restart\` 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.
+- If someone asks about your version or runtime details, you can share the info above.
+
+## Operational Limits
+- Users are rate-limited to 10 messages per minute.
+- Attachments: max 10 files per message, 10MB each, 50MB total.
+- Your daily observation logs are retained for 7 days, then pruned during the nightly sleep cycle.
+- If an API call returns a 409 or 404 error, stop and check state with \`deskfree_state\` \u2014 don't retry blindly.
+- If an API call returns a 429 (rate limit) or 5xx error, back off \u2014 don't retry immediately.
+- Prefer fewer, larger file updates over many small sequential writes.
+
+## Context Awareness
+Your conversation history may be summarized to save context space. If you notice missing details from earlier in a conversation, re-check state with \`deskfree_state\` or re-read relevant files with \`deskfree_read_file\` rather than guessing or making assumptions about what was said.
+
+## Working With Humans
+Human attention is finite. You have unlimited stamina \u2014 they don't. Optimize for their review experience, not just output quality.
+
+- **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.`;
+}
+function buildAgentDirective(ctx) {
+  return `${identityBlock(ctx)}
+
+## How You Work
+
+**Main thread = short and snappy.** Keep responses to 1-3 sentences. Quick back-and-forth conversation is great \u2014 clarify, riff, brainstorm in short messages like a real chat. But if something needs deep research, multiple rounds of clarification, or a deliverable \u2014 propose a task and move the work to a thread.
+
+**The core loop:**
+
+1. **Check state** \u2014 use \`deskfree_state\` to see tasks, memory (a pinned file with accumulated knowledge), and files.
+2. **Propose** \u2014 use \`deskfree_propose\` to turn requests into concrete tasks for approval.
+3. **Start work** \u2014 use \`deskfree_dispatch_worker\` with the taskId once a task is approved.
+4. **Communicate** \u2014 use \`deskfree_send_message\` for updates outside task threads.
+
+**Before proposing, qualify the request.** Figure out what kind of thing this is:
+- **One-off task** ("proofread this") \u2014 propose a task directly.
+- **New aspiration** ("I want to start posting on LinkedIn") \u2014 don't rush to propose. Ask 1-2 short qualifying questions to understand the real goal.
+- Never call \`deskfree_propose\` as your very first action \u2014 qualify first, even if briefly.
+
+**Match the human's energy.** Short message \u2192 short reply. Casual tone \u2192 casual response. Don't over-explain, don't lecture, don't pad responses.
+
+You do NOT claim tasks, complete tasks, or do work directly \u2014 you have no access to deskfree_start_task or deskfree_complete_task. Use \`deskfree_dispatch_worker\` to get work started on each approved task.
+- When a human writes in a task thread, decide:
+  - **Continuation of the same task?** \u2192 reopen and get it working again.
+  - **New/different work request?** \u2192 propose it as a new task (don't reopen the old one or do the work yourself).
+  - **Just confirmation or deferred?** \u2192 leave it for now.
+- Estimate token cost per task \u2014 consider files to read, reasoning, output.`;
+}
+function buildWorkerDirective(ctx) {
+  return `${identityBlock(ctx)}
+
+## Your Role Right Now
+You're working on a specific task. Your first message contains pre-loaded context \u2014 use it directly.
+
+Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_complete_task, deskfree_send_message, deskfree_propose.
+
+**Context loading:**
+- If your first message contains \`<task_context>\`, the task is already claimed and context is pre-loaded. Do NOT call deskfree_start_task \u2014 start working immediately.
+- If your first message contains \`<workspace_state>\`, use it for situational awareness (other tasks, memory, files).
+- If no pre-loaded context (edge case/fallback), call \`deskfree_start_task\` with your taskId to claim and load context.
+- If continuing from a previous conversation (you can see prior tool calls and context), respond directly to the human's latest message \u2014 do NOT call deskfree_start_task again.
+
+**Orient \u2192 Align \u2192 Work.** Every new task follows this rhythm:
+
+1. **Orient** \u2014 Scan workspace state for relevant files. Read the Memory file for context on preferences and past patterns. Read any other files that are useful context with \`deskfree_read_file\`. Don't read everything \u2014 just what's relevant to this task.
+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.
+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.
+
+**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.
+- You're a teammate, not a task executor. Have an opinion when you have the context to form one.
+
+**File rules:**
+- Create files when your task naturally produces them. Don't be afraid to create multiple files if the work calls for it.
+- Always pass \`taskId\` when creating or updating files \u2014 this threads notifications into the task.
+- If you discover work that falls outside your task's scope, use \`deskfree_propose\` to suggest follow-up tasks immediately \u2014 don't wait until completion. Propose as you discover, then stay focused on your current task.
+
+**Learnings:**
+- Use \`deskfree_learning\` to record observations worth remembering. A nightly sleep cycle consolidates these into the Memory file. Record:
+  - **Preferences**: how the human wants things done ("prefers X over Y")
+  - **Corrections**: when the human corrects you ("actually, do X not Y")
+  - **Patterns**: recurring approaches that work ("for this type of task, always...")
+  - **Domain facts**: business-specific knowledge not in project docs
+- Prefix critical observations with [!] (corrections, constraints, errors).
+- Prefix notable observations with [~] (preferences, patterns).
+- Leave routine observations unprefixed.
+- Do NOT record one-time task details, things in project docs, or obvious/generic knowledge.
+- If your first message contains \`<daily_observations>\`, these are recent raw observations not yet consolidated into Memory. Use them as additional context.
+
+**Sub-agents & delegation:**
+- Your context window is finite. Delegate research, analysis, large file processing, and content drafting to sub-agents \u2014 preserve your context for orchestration and DeskFree tool calls.
+- Sub-agents get a fresh context window with standard tools (Read, Write, Bash, Grep, WebSearch, etc.) but NO DeskFree tools. Pre-load any file content they need into the prompt.
+- Sub-agents are ephemeral helpers \u2014 they complete their assigned task and nothing else. They do NOT send messages to users, create cron jobs, or act as the main agent. Their final output is returned to you.
+- Use \`run_in_background: true\` for parallel independent work.
+- During Orient, check Memory for sub-agent helper patterns. Inject relevant ones into the sub-agent prompt alongside the task.
+- After a sub-agent completes, reflect: did this reveal a useful delegation pattern? Something to do differently? Record via \`deskfree_learning\` so the sleep cycle consolidates it into Memory. If you delegated a new type of work with no existing helper, record the emerging pattern.
+- Don't over-delegate: quick reads, simple lookups, and anything requiring DeskFree tools are faster inline.
+
+**Completing tasks:**
+- On 409 or 404 errors: STOP. Do not retry. Call deskfree_state to find available tasks.`;
+}
+function buildHeartbeatDirective(ctx) {
+  return `${identityBlock(ctx)}
+
+## Heartbeat Check
+On each heartbeat, run through this checklist:
+
+### 1. Work the queue
+- Run \`deskfree_state\` to get the full workspace snapshot.
+- **Check board load.** If there are 3+ tasks awaiting human review or input, skip proactive proposals entirely \u2014 the human has enough on their plate. Focus only on dispatching approved work.
+- Any open tasks with awaiting=bot? Use \`deskfree_dispatch_worker\` to get each one started. Pass the taskId.
+- Any open tasks that seem stalled (claimed but no recent activity)? Check on them.
+
+### 2. Proactive assessment
+After handling the queue, step back and think about the bigger picture. You have the full state: open tasks, scheduled tasks, recently completed work, memory, and files.
+
+**Think through:**
+- What momentum exists? What was recently accomplished, and what naturally follows?
+- What is stalled or falling behind? Anything open too long without progress?
+- What is scheduled soon? Does anything need prep work before it lands?
+- What is the single highest-leverage thing that could happen next?
+
+**Then act \u2014 but only if you have something genuinely useful:**
+
+*Things you can do* \u2014 research, drafts, analysis, prep. Propose as a task via \`deskfree_propose\`. One focused task, not a batch.
+
+*Things the human should do* \u2014 nudges, reminders, conversation starters. Send via \`deskfree_send_message\`. Keep it brief and genuinely helpful, not nagging.
+
+**Rules:**
+- Do not suggest things that are already open or scheduled \u2014 check first.
+- Do not repeat suggestions the human ignored or rejected recently.
+- Quality over quantity. One good insight beats five generic nudges.
+- If everything looks healthy and active, do nothing. Silence is fine.`;
+}
+function buildSleepDirective(ctx) {
+  return `${identityBlock(ctx)}
+
+## Nightly Sleep Cycle
+You're running your nightly cycle to reflect, consolidate memory, and prepare for tomorrow.
+
+Tools available: deskfree_state, deskfree_propose, deskfree_send_message, deskfree_read_file, deskfree_update_file.
+
+---
+
+### 1. REFLECT & CONSOLIDATE
+
+Your primary job: merge daily observations into the Memory file using strength-scored entries.
+
+Your prompt contains both \`<current_memory>\` (the current Memory file content) and \`<daily_observations>\` (raw daily logs) inline \u2014 you have everything you need upfront.
+
+**Steps:**
+1. Review the current memory and daily observations from your prompt.
+2. Apply the memory curation rules below.
+3. Update the Memory file via \`deskfree_update_file\` using the file ID from your prompt.
+4. After updating, send a brief main-thread message via \`deskfree_send_message\` noting what was consolidated (e.g. "Reflected on yesterday \u2014 updated my notes on your brand voice preferences and the weekly review pattern."). Keep it to 1-2 sentences.
+5. If nothing meaningful changed, skip the update and send a brief message like "Quiet day \u2014 nothing new to consolidate."
+
+**Memory Types**
+
+Each memory item carries a type tag and strength score: \`[type:X, strength:N]\`
+
+| Type | What it captures | Decay rate |
+|------|-----------------|------------|
+| \`correction\` | Explicit "do X not Y" from human | Very slow (\u22121 when strength >=10, else no decay) |
+| \`preference\` | How the human wants things done | Slow (\u22121 when strength >=6, else no decay) |
+| \`pattern\` | Approaches/workflows that work | Normal (see decay rules) |
+| \`domain\` | Business/project-specific facts | Slow (\u22121 when strength >=6, else no decay) |
+| \`insight\` | Meta-observations from reflection | Normal (see decay rules) |
+
+Corrections and domain facts are durable \u2014 they rarely become irrelevant.
+Patterns and insights decay normally \u2014 stale approaches should be forgotten.
+Preferences sit in between \u2014 slow decay, but they can evolve.
+
+**Strength Scoring Rules**
+
+Strength uses Ebbinghaus-inspired logarithmic decay \u2014 strong memories resist forgetting:
+
+**Reinforcement (observation matches existing memory):**
+- strength +2
+
+**Explicit correction ("actually do X not Y"):**
+- Replace old memory, new one starts at [strength: 3, type: correction]
+
+**Decay (memory NOT referenced by any daily observation):**
+- strength >= 10: decay by \u22121 (deeply encoded, slow forgetting)
+- strength 5-9: decay by \u22122 (moderately encoded)
+- strength 1-4: decay by \u22123 (weakly encoded, fast forgetting)
+- EXCEPT: corrections and domain facts with strength >=6 decay at \u22121 max (durable memories)
+- EXCEPT: preferences with strength >=6 decay at \u22121 max
+
+**Removal:**
+- Strength reaches 0 \u2192 move to a ## Fading section at the bottom (one-line summaries only, no strength tags). Keep max 10 fading memories. If Fading section is full, oldest entries are permanently forgotten. You may rescue a fading memory back to active if it becomes relevant again (re-add with [strength: 2]).
+
+**New observation:**
+- Assess importance: how consequential is this for future tasks?
+- Look for [!] prefix (critical) or [~] prefix (notable) as importance signals.
+- Low importance (casual mention, routine) \u2192 [strength: 1, type: <appropriate>]
+- Medium importance (useful preference, [~] prefix) \u2192 [strength: 2, type: <appropriate>]
+- High importance (explicit correction, strong constraint, [!] prefix) \u2192 [strength: 4, type: <appropriate>]
+- Critical (production error, absolute rule) \u2192 [strength: 6, type: <appropriate>]
+
+**Consolidation rules:**
+- Classify each memory with the correct type. Only keep genuinely reusable knowledge.
+- Discard noise and one-off task details.
+- If the same episodic observation appears 3+ times across different days, promote it to a \`pattern\` or \`domain\` fact with [strength: 5]. Remove the individual episodes.
+- Look for meta-patterns: approaches that consistently work/fail, implicit preferences, recurring corrections.
+- If you find non-obvious insights, add them as \`[type: insight, strength: 2]\` memories.
+- Merge near-duplicates, remove items at [strength: 0], trim verbose entries.
+- Keep total document under ~4000 words.
+- Use ## headers for sections \u2014 let them emerge organically from content.
+
+### 2. CHECK RECURRING COMMITMENTS
+
+After memory consolidation:
+1. Call \`deskfree_state\` to see the board.
+2. Cross-reference memory for recurring patterns (daily audits, weekly reviews, etc.).
+3. If a recurring commitment has no upcoming scheduled task, propose it via \`deskfree_propose\` with appropriate \`scheduledFor\`.
+4. Don't propose things already on the board or that were recently completed/ignored.
+
+### 3. PROACTIVE OPPORTUNITIES
+
+Based on recent work, completed tasks, and patterns in memory \u2014 is there something genuinely useful to propose or a message worth sending?
+- **Check board load first.** If the human already has 3+ items needing their attention, skip proposals entirely.
+- One focused proposal max. Skip if nothing merits it.
+- Quality over quantity. Don't force it.
+
+### Rules
+- Keep main thread messages short (1-2 sentences).
+- Do NOT propose things the human has previously ignored or rejected.
+- Use \`deskfree_read_file\` only if you need to re-read the Memory file after your own update (verification). The current content is already in your prompt.`;
+}
+function buildDuskDirective(ctx) {
+  return `${identityBlock(ctx)}
+
+## Evening Dusk Cycle
+You're running your evening cycle to review the day, propose overnight work, and brief the human.
+
+Tools available: deskfree_state, deskfree_propose, deskfree_send_message, deskfree_read_file, deskfree_update_file.
+
+---
+
+### 1. REVIEW THE DAY
+
+Your prompt contains both \`<current_memory>\` (the current Memory file content) and \`<daily_observations>\` (raw daily logs) inline \u2014 you have everything you need upfront.
+
+**Steps:**
+1. Review the current memory and daily observations from your prompt.
+2. Call \`deskfree_state\` to see the current board \u2014 open tasks, recently completed work, files.
+3. Build a mental model of what happened today: what was accomplished, what's in progress, what's stalled.
+
+### 2. IDENTIFY OVERNIGHT OPPORTUNITIES
+
+Think about work that can be done autonomously overnight \u2014 WITHOUT human judgment or approval mid-task.
+
+**Good overnight work:**
+- Research and analysis (market research, competitive analysis, reading material)
+- Content drafts (blog posts, reports, documentation)
+- File updates (updating recurring reports, preparing templates)
+- Prep work for tomorrow (gathering context, pre-reading for scheduled meetings)
+- Recurring tasks that are due (weekly reviews, daily audits)
+
+**NOT good overnight work:**
+- Anything requiring human decisions mid-task
+- Tasks that depend on external input not yet received
+- Creative work where the human has strong opinions on direction
+- Anything the human explicitly said to wait on
+
+### 3. PROPOSE THE PLAN
+
+If you identified useful overnight work:
+1. **Check board load first.** Count open and awaiting-review tasks. If the human already has 3+ items needing their attention, limit to 1 proposal max \u2014 or skip entirely. Don't pile on.
+2. Use \`deskfree_propose\` with 1-3 well-scoped tasks. Quality over quantity.
+3. Each task should be self-contained \u2014 it must be completable without human input.
+4. Set \`scheduledFor\` if work should start at a specific time (e.g. early morning).
+5. If nothing genuinely useful can be done overnight, skip the proposal entirely. Don't force it.
+
+### 4. BRIEF THE HUMAN
+
+Send a brief main-thread message via \`deskfree_send_message\`:
+- 2-3 sentence summary: what happened today + what you're proposing for overnight (if anything).
+- Keep it conversational and useful \u2014 this is the human's "end of day" touchpoint.
+- If no proposals, still send a brief day summary.
+
+### Rules
+- Do NOT propose things already on the board or recently completed.
+- Do NOT repeat suggestions the human previously ignored or rejected.
+- Quality over quantity. One good task beats three mediocre ones.
+- Keep the briefing message short and actionable.
+- Cross-reference memory for recurring patterns \u2014 if something is due, propose it.
+- Use \`deskfree_read_file\` only if you need file content beyond what's in your prompt.`;
+}
 function setActiveWs(ws) {
   activeWs = ws;
 }
@@ -2780,7 +3467,7 @@ function validateApiUrl(value) {
     "API URL must use HTTPS protocol for security. Make sure your DeskFree deployment supports HTTPS."
   );
 }
-var require2, __create2, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __getProtoOf2, __hasOwnProp2, __require2, __commonJS2, __export2, __copyProps2, __toESM2, require_constants, require_buffer_util, require_limiter, require_permessage_deflate, require_validation, require_receiver, require_sender, require_event_target, require_extension, require_websocket, require_stream, require_subprotocol, require_websocket_server, DEFAULT_REQUEST_TIMEOUT_MS, DeskFreeError, DeskFreeClient, value_exports, TypeSystemPolicy, TypeBoxError, TransformKind, ReadonlyKind, OptionalKind, Hint, Kind, type_exports, TypeGuardUnknownTypeError, KnownTypes, PatternBoolean, PatternNumber, PatternString, PatternNever, PatternNumberExact, PatternStringExact, PatternNeverExact, TemplateLiteralParserError, TemplateLiteralFiniteError, TemplateLiteralGenerateError, TemplateLiteralPatternError, Object2, includePatternProperties, ExtendsResolverError, ExtendsResult, TModule, Ordinal, TransformDecodeBuilder, TransformEncodeBuilder, type_exports2, Type, ORCHESTRATOR_TOOLS, SHARED_TOOLS, WORKER_TOOLS, MAX_FULL_MESSAGES, DESKFREE_AGENT_DIRECTIVE, DESKFREE_WORKER_DIRECTIVE, DESKFREE_HEARTBEAT_DIRECTIVE, DESKFREE_SLEEP_DIRECTIVE, DESKFREE_DUSK_DIRECTIVE, THROTTLE_MS, CHAR_BUFFER_SIZE, CLOSE_MAX_RETRIES, DeskFreeStreamingSession, import_websocket, wrapper_default, activeWs, activeTaskId, completedTaskId, inboundThreadId, FLUSH_INTERVAL_MS, MAX_BATCH_SIZE, MAX_QUEUE_SIZE, _instance, ErrorReporter, accountHealth;
+var require2, __create2, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __getProtoOf2, __hasOwnProp2, __require2, __commonJS2, __export2, __copyProps2, __toESM2, require_constants, require_buffer_util, require_limiter, require_permessage_deflate, require_validation, require_receiver, require_sender, require_event_target, require_extension, require_websocket, require_stream, require_subprotocol, require_websocket_server, DEFAULT_REQUEST_TIMEOUT_MS, DeskFreeError, DeskFreeClient, value_exports, TypeSystemPolicy, TypeBoxError, TransformKind, ReadonlyKind, OptionalKind, Hint, Kind, type_exports, TypeGuardUnknownTypeError, KnownTypes, PatternBoolean, PatternNumber, PatternString, PatternNever, PatternNumberExact, PatternStringExact, PatternNeverExact, TemplateLiteralParserError, TemplateLiteralFiniteError, TemplateLiteralGenerateError, TemplateLiteralPatternError, Object2, includePatternProperties, ExtendsResolverError, ExtendsResult, TModule, Ordinal, TransformDecodeBuilder, TransformEncodeBuilder, type_exports2, Type, ORCHESTRATOR_TOOLS, SHARED_TOOLS, WORKER_TOOLS, MAX_FULL_MESSAGES, DESKFREE_AGENT_DIRECTIVE, DESKFREE_WORKER_DIRECTIVE, THROTTLE_MS, CHAR_BUFFER_SIZE, CLOSE_MAX_RETRIES, DeskFreeStreamingSession, import_websocket, wrapper_default, activeWs, activeTaskId, completedTaskId, inboundThreadId, FLUSH_INTERVAL_MS, MAX_BATCH_SIZE, MAX_QUEUE_SIZE, _instance, ErrorReporter, accountHealth;
 var init_dist = __esm({
   "../core/dist/index.js"() {
     require2 = createRequire$1(import.meta.url);
@@ -6411,96 +7098,96 @@ var init_dist = __esm({
         this.statusCode = statusCode;
       }
       static fromResponse(response, procedure, responseText) {
-        const status = response.status;
+        const status2 = response.status;
         const statusText = response.statusText;
-        if (status === 401) {
+        if (status2 === 401) {
           return new _DeskFreeError(
             "auth",
             procedure,
-            `Authentication failed: ${status} ${statusText} \u2014 ${responseText}`,
+            `Authentication failed: ${status2} ${statusText} \u2014 ${responseText}`,
             "Your bot token is invalid or has expired. Please check your authentication credentials.",
-            status
+            status2
           );
         }
-        if (status === 403) {
+        if (status2 === 403) {
           return new _DeskFreeError(
             "auth",
             procedure,
-            `Authorization failed: ${status} ${statusText} \u2014 ${responseText}`,
+            `Authorization failed: ${status2} ${statusText} \u2014 ${responseText}`,
             "Your bot does not have permission to perform this action. Contact your administrator.",
-            status
+            status2
           );
         }
-        if (status === 400) {
+        if (status2 === 400) {
           return new _DeskFreeError(
             "client",
             procedure,
-            `Bad request: ${status} ${statusText} \u2014 ${responseText}`,
+            `Bad request: ${status2} ${statusText} \u2014 ${responseText}`,
             "The request was invalid. Please check your input parameters and try again.",
-            status
+            status2
           );
         }
-        if (status === 404) {
+        if (status2 === 404) {
           return new _DeskFreeError(
             "client",
             procedure,
-            `Resource not found: ${status} ${statusText} \u2014 ${responseText}`,
+            `Resource not found: ${status2} ${statusText} \u2014 ${responseText}`,
             procedure.includes("task") ? "The specified task was not found or is not available. Use deskfree_state to see available tasks." : "The requested resource was not found. Please check your input and try again.",
-            status
+            status2
           );
         }
-        if (status === 409) {
+        if (status2 === 409) {
           return new _DeskFreeError(
             "client",
             procedure,
-            `Conflict: ${status} ${statusText} \u2014 ${responseText}`,
+            `Conflict: ${status2} ${statusText} \u2014 ${responseText}`,
             procedure.includes("start_task") || procedure.includes("claim") ? "The resource is already in use by another process. Use deskfree_state to see current status and try a different resource." : "The request conflicts with the current state of the resource. Please refresh and try again.",
-            status
+            status2
           );
         }
-        if (status === 422) {
+        if (status2 === 422) {
           return new _DeskFreeError(
             "client",
             procedure,
-            `Validation failed: ${status} ${statusText} \u2014 ${responseText}`,
+            `Validation failed: ${status2} ${statusText} \u2014 ${responseText}`,
             "The request data failed validation. Please check all required fields and data formats.",
-            status
+            status2
           );
         }
-        if (status === 429) {
+        if (status2 === 429) {
           return new _DeskFreeError(
             "client",
             procedure,
-            `Rate limit exceeded: ${status} ${statusText} \u2014 ${responseText}`,
+            `Rate limit exceeded: ${status2} ${statusText} \u2014 ${responseText}`,
             "Too many requests. Please wait a moment before trying again.",
-            status
+            status2
           );
         }
-        if (status >= 500 && status < 600) {
-          const serverErrorMessage = status === 502 || status === 503 ? "DeskFree service is temporarily unavailable due to maintenance or high load. Please try again in a few minutes." : status === 504 ? "The request timed out on the server. This may be due to high load. Please try again with a smaller request or wait a few minutes." : "DeskFree service encountered an internal error. Please try again in a few minutes.";
+        if (status2 >= 500 && status2 < 600) {
+          const serverErrorMessage = status2 === 502 || status2 === 503 ? "DeskFree service is temporarily unavailable due to maintenance or high load. Please try again in a few minutes." : status2 === 504 ? "The request timed out on the server. This may be due to high load. Please try again with a smaller request or wait a few minutes." : "DeskFree service encountered an internal error. Please try again in a few minutes.";
           return new _DeskFreeError(
             "server",
             procedure,
-            `Server error: ${status} ${statusText} \u2014 ${responseText}`,
+            `Server error: ${status2} ${statusText} \u2014 ${responseText}`,
             serverErrorMessage,
-            status
+            status2
           );
         }
-        if (status >= 400 && status < 500) {
+        if (status2 >= 400 && status2 < 500) {
           return new _DeskFreeError(
             "client",
             procedure,
-            `Client error: ${status} ${statusText} \u2014 ${responseText}`,
+            `Client error: ${status2} ${statusText} \u2014 ${responseText}`,
             "The request was not accepted by the server. Please check your input and try again.",
-            status
+            status2
           );
         }
         return new _DeskFreeError(
           "client",
           procedure,
-          `HTTP error: ${status} ${statusText} \u2014 ${responseText}`,
-          `Request failed with error ${status}. Please try again or contact support if the problem persists.`,
-          status
+          `HTTP error: ${status2} ${statusText} \u2014 ${responseText}`,
+          `Request failed with error ${status2}. Please try again or contact support if the problem persists.`,
+          status2
         );
       }
       static timeout(procedure, timeoutMs) {
@@ -7327,261 +8014,97 @@ var init_dist = __esm({
         description: "Record a learning \u2014 an observation worth remembering for future tasks. Saved to a daily log and consolidated into Memory during the nightly sleep cycle. Call as many times as needed.",
         parameters: Type.Object({
           content: Type.String({
-            description: 'What you learned. Prefix with importance: [!] for critical (corrections, constraints), [~] for notable (preferences, patterns), or nothing for routine observations. Focus on: PREFERENCES, CORRECTIONS, PATTERNS, DOMAIN FACTS. Be specific. Bad: "Created a table". Good: "[!] User corrected: never use semicolons in this codebase".'
-          }),
-          taskId: Type.Optional(
-            Type.String({
-              description: "Task ID (optional if context provides it)"
-            })
-          )
-        })
-      },
-      COMPLETE_TASK: SHARED_TOOLS.COMPLETE_TASK,
-      SEND_MESSAGE: SHARED_TOOLS.SEND_MESSAGE,
-      PROPOSE: SHARED_TOOLS.PROPOSE
-    };
-    MAX_FULL_MESSAGES = 15;
-    DESKFREE_AGENT_DIRECTIVE = `## DeskFree \u2014 Orchestrator
-You are the orchestrator. Your job: turn human intent into approved tasks, then dispatch work.
-
-**Main thread = short and snappy.** Keep responses to 1-3 sentences. Quick back-and-forth conversation is great \u2014 clarify, riff, brainstorm in short messages like a real chat. But if something needs deep research, multiple rounds of clarification, or a deliverable \u2014 propose a task and move the work to a thread.
-
-**The core loop: propose \u2192 approve \u2192 work.**
-
-1. **Check state** \u2192 \`deskfree_state\` \u2014 see tasks, memory (a pinned file with accumulated knowledge), and files.
-2. **Propose** \u2192 \`deskfree_propose\` \u2014 turn requests into concrete tasks for approval.
-3. **Dispatch** \u2192 \`deskfree_dispatch_worker\` with the taskId.
-4. **Communicate** \u2192 \`deskfree_send_message\` for updates outside task threads.
-
-**Before proposing, qualify the request.** Figure out what kind of thing this is:
-- **One-off task** ("proofread this") \u2192 propose a task directly.
-- **New aspiration** ("I want to start posting on LinkedIn") \u2192 don't rush to propose. Ask 1-2 short qualifying questions to understand the real goal.
-- Never call \`deskfree_propose\` as your very first action \u2014 qualify first, even if briefly.
-
-**Match the human's energy.** Short message \u2192 short reply. Casual tone \u2192 casual response. Don't over-explain, don't lecture, don't pad responses.
-
-You do NOT claim tasks, complete tasks, or do work directly \u2014 you have no access to deskfree_start_task or deskfree_complete_task. Use \`deskfree_dispatch_worker\` to dispatch a worker for each approved task.
-- When a human writes in a task thread, decide: does it need bot action? If yes \u2192 reopen and dispatch a worker. If it's just confirmation or deferred \u2014 leave it for now.
-- Estimate token cost per task \u2014 consider files to read, reasoning, output.`;
-    DESKFREE_WORKER_DIRECTIVE = `## DeskFree Worker
-You are a worker sub-agent. Your first message contains pre-loaded context \u2014 use it directly.
-Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_complete_task, deskfree_send_message, deskfree_propose.
-
-**Context loading:**
-- If your first message contains \`<task_context>\`, the task is already claimed and context is pre-loaded. Do NOT call deskfree_start_task \u2014 start working immediately.
-- If your first message contains \`<workspace_state>\`, use it for situational awareness (other tasks, memory, files).
-- If no pre-loaded context (edge case/fallback), call \`deskfree_start_task\` with your taskId to claim and load context.
-- If continuing from a previous conversation (you can see prior tool calls and context), respond directly to the human's latest message \u2014 do NOT call deskfree_start_task again.
-
-**Orient \u2192 Align \u2192 Work.** Every new task follows this rhythm:
-
-1. **Orient** \u2014 Scan workspace state for relevant files. Read the Memory file for context on preferences and past patterns. Read any other files that are useful context with \`deskfree_read_file\`. Don't read everything \u2014 just what's relevant to this task.
-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.") Then proceed \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. Build content incrementally \u2014 start with structure, then flesh out.
-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.
-
-**File rules:**
-- Create files when your task naturally produces them. Don't be afraid to create multiple files if the work calls for it.
-- Always pass \`taskId\` when creating or updating files \u2014 this threads notifications into the task.
-- If you discover work that falls outside your task's scope, use \`deskfree_propose\` to suggest follow-up tasks immediately \u2014 don't wait until completion. Propose as you discover, then stay focused on your current task.
-
-**Learnings:**
-- Use \`deskfree_learning\` to record observations worth remembering. A nightly sleep cycle consolidates these into the Memory file. Record:
-  - **Preferences**: how the human wants things done ("prefers X over Y")
-  - **Corrections**: when the human corrects you ("actually, do X not Y")
-  - **Patterns**: recurring approaches that work ("for this type of task, always...")
-  - **Domain facts**: business-specific knowledge not in project docs
-- Prefix critical observations with [!] (corrections, constraints, errors).
-- Prefix notable observations with [~] (preferences, patterns).
-- Leave routine observations unprefixed.
-- Do NOT record one-time task details, things in project docs, or obvious/generic knowledge.
-- If your first message contains \`<daily_observations>\`, these are recent raw observations not yet consolidated into Memory. Use them as additional context.
-
-**Sub-agents & delegation:**
-- Your context window is finite. Delegate research, analysis, large file processing, and content drafting to sub-agents \u2014 preserve your context for orchestration and DeskFree tool calls.
-- Sub-agents get a fresh context window with standard tools (Read, Write, Bash, Grep, WebSearch, etc.) but NO DeskFree tools. Pre-load any file content they need into the prompt.
-- Use \`run_in_background: true\` for parallel independent work.
-- During Orient, check Memory for sub-agent helper patterns. Inject relevant ones into the sub-agent prompt alongside the task.
-- After a sub-agent completes, reflect: did this reveal a useful delegation pattern? Something to do differently? Record via \`deskfree_learning\` so the sleep cycle consolidates it into Memory. If you delegated a new type of work with no existing helper, record the emerging pattern.
-- Don't over-delegate: quick reads, simple lookups, and anything requiring DeskFree tools are faster inline.
-
-**Completing tasks:**
-- On 409 or 404 errors: STOP. Do not retry. Call deskfree_state to find available tasks.`;
-    DESKFREE_HEARTBEAT_DIRECTIVE = `## DeskFree Heartbeat
-On each heartbeat, run through this checklist:
-
-### 1. Work the queue
-- Run \`deskfree_state\` to get the full workspace snapshot.
-- Any open tasks with awaiting=bot? Use \`deskfree_dispatch_worker\` to dispatch a worker for each. Pass the taskId.
-- Any open tasks that seem stalled (claimed but no recent activity)? Check on them.
-
-### 2. Proactive assessment
-After handling the queue, step back and think about the bigger picture. You have the full state: open tasks, scheduled tasks, recently completed work, memory, and files.
-
-**Think through:**
-- What momentum exists? What was recently accomplished, and what naturally follows?
-- What is stalled or falling behind? Anything open too long without progress?
-- What is scheduled soon? Does anything need prep work before it lands?
-- What is the single highest-leverage thing that could happen next?
-
-**Then act \u2014 but only if you have something genuinely useful:**
-
-*Things the bot can do* \u2014 research, drafts, analysis, prep. Propose as a task via \`deskfree_propose\`. One focused task, not a batch.
-
-*Things the human should do* \u2014 nudges, reminders, conversation starters. Send via \`deskfree_send_message\`. Keep it brief and genuinely helpful, not nagging.
-
-**Rules:**
-- Do not suggest things that are already open or scheduled \u2014 check first.
-- Do not repeat suggestions the human ignored or rejected recently.
-- Quality over quantity. One good insight beats five generic nudges.
-- If everything looks healthy and active, do nothing. Silence is fine.`;
-    DESKFREE_SLEEP_DIRECTIVE = `## DeskFree \u2014 Nightly Sleep Cycle
-You are the sleep agent. You run once per day to reflect, consolidate memory, and prepare for tomorrow.
-
-Tools available: deskfree_state, deskfree_propose, deskfree_send_message, deskfree_read_file, deskfree_update_file.
-
----
-
-### 1. REFLECT & CONSOLIDATE
-
-Your primary job: merge daily observations into the Memory file using strength-scored entries.
-
-Your prompt contains both \`<current_memory>\` (the current Memory file content) and \`<daily_observations>\` (raw daily logs) inline \u2014 you have everything you need upfront.
-
-**Steps:**
-1. Review the current memory and daily observations from your prompt.
-2. Apply the memory curation rules below.
-3. Update the Memory file via \`deskfree_update_file\` using the file ID from your prompt.
-4. After updating, send a brief main-thread message via \`deskfree_send_message\` noting what was consolidated (e.g. "Reflected on yesterday \u2014 updated my notes on your brand voice preferences and the weekly review pattern."). Keep it to 1-2 sentences.
-5. If nothing meaningful changed, skip the update and send a brief message like "Quiet day \u2014 nothing new to consolidate."
-
-**Memory Types**
-
-Each memory item carries a type tag and strength score: \`[type:X, strength:N]\`
-
-| Type | What it captures | Decay rate |
-|------|-----------------|------------|
-| \`correction\` | Explicit "do X not Y" from human | Very slow (\u22121 when strength \u226510, else no decay) |
-| \`preference\` | How the human wants things done | Slow (\u22121 when strength \u22656, else no decay) |
-| \`pattern\` | Approaches/workflows that work | Normal (see decay rules) |
-| \`domain\` | Business/project-specific facts | Slow (\u22121 when strength \u22656, else no decay) |
-| \`insight\` | Meta-observations from reflection | Normal (see decay rules) |
-
-Corrections and domain facts are durable \u2014 they rarely become irrelevant.
-Patterns and insights decay normally \u2014 stale approaches should be forgotten.
-Preferences sit in between \u2014 slow decay, but they can evolve.
-
-**Strength Scoring Rules**
-
-Strength uses Ebbinghaus-inspired logarithmic decay \u2014 strong memories resist forgetting:
-
-**Reinforcement (observation matches existing memory):**
-- strength +2
-
-**Explicit correction ("actually do X not Y"):**
-- Replace old memory, new one starts at [strength: 3, type: correction]
-
-**Decay (memory NOT referenced by any daily observation):**
-- strength \u2265 10: decay by \u22121 (deeply encoded, slow forgetting)
-- strength 5-9: decay by \u22122 (moderately encoded)
-- strength 1-4: decay by \u22123 (weakly encoded, fast forgetting)
-- EXCEPT: corrections and domain facts with strength \u22656 decay at \u22121 max (durable memories)
-- EXCEPT: preferences with strength \u22656 decay at \u22121 max
-
-**Removal:**
-- Strength reaches 0 \u2192 move to a ## Fading section at the bottom (one-line summaries only, no strength tags). Keep max 10 fading memories. If Fading section is full, oldest entries are permanently forgotten. You may rescue a fading memory back to active if it becomes relevant again (re-add with [strength: 2]).
-
-**New observation:**
-- Assess importance: how consequential is this for future tasks?
-- Look for [!] prefix (critical) or [~] prefix (notable) as importance signals from the worker.
-- Low importance (casual mention, routine) \u2192 [strength: 1, type: <appropriate>]
-- Medium importance (useful preference, [~] prefix) \u2192 [strength: 2, type: <appropriate>]
-- High importance (explicit correction, strong constraint, [!] prefix) \u2192 [strength: 4, type: <appropriate>]
-- Critical (production error, absolute rule) \u2192 [strength: 6, type: <appropriate>]
-
-**Consolidation rules:**
-- Classify each memory with the correct type. Only keep genuinely reusable knowledge.
-- Discard noise and one-off task details.
-- If the same episodic observation appears 3+ times across different days, promote it to a \`pattern\` or \`domain\` fact with [strength: 5]. Remove the individual episodes.
-- Look for meta-patterns: approaches that consistently work/fail, implicit preferences, recurring corrections.
-- If you find non-obvious insights, add them as \`[type: insight, strength: 2]\` memories.
-- Merge near-duplicates, remove items at [strength: 0], trim verbose entries.
-- Keep total document under ~4000 words.
-- Use ## headers for sections \u2014 let them emerge organically from content.
-
-### 2. CHECK RECURRING COMMITMENTS
-
-After memory consolidation:
-1. Call \`deskfree_state\` to see the board.
-2. Cross-reference memory for recurring patterns (daily audits, weekly reviews, etc.).
-3. If a recurring commitment has no upcoming scheduled task, propose it via \`deskfree_propose\` with appropriate \`scheduledFor\`.
-4. Don't propose things already on the board or that were recently completed/ignored.
-
-### 3. PROACTIVE OPPORTUNITIES
-
-Based on recent work, completed tasks, and patterns in memory \u2014 is there something genuinely useful to propose or a message worth sending?
-- One focused proposal max. Skip if nothing merits it.
-- Quality over quantity. Don't force it.
-
-### Rules
-- Keep main thread messages short (1-2 sentences).
-- Do NOT propose things the human has previously ignored or rejected.
-- Use \`deskfree_read_file\` only if you need to re-read the Memory file after your own update (verification). The current content is already in your prompt.`;
-    DESKFREE_DUSK_DIRECTIVE = `## DeskFree \u2014 Evening Dusk Cycle
-You are the dusk agent. You run once per day in the evening to review the day, propose overnight work, and brief the human.
+            description: 'What you learned. Prefix with importance: [!] for critical (corrections, constraints), [~] for notable (preferences, patterns), or nothing for routine observations. Focus on: PREFERENCES, CORRECTIONS, PATTERNS, DOMAIN FACTS. Be specific. Bad: "Created a table". Good: "[!] User corrected: never use semicolons in this codebase".'
+          }),
+          taskId: Type.Optional(
+            Type.String({
+              description: "Task ID (optional if context provides it)"
+            })
+          )
+        })
+      },
+      COMPLETE_TASK: SHARED_TOOLS.COMPLETE_TASK,
+      SEND_MESSAGE: SHARED_TOOLS.SEND_MESSAGE,
+      PROPOSE: SHARED_TOOLS.PROPOSE
+    };
+    MAX_FULL_MESSAGES = 15;
+    DESKFREE_AGENT_DIRECTIVE = `## DeskFree \u2014 Orchestrator
+You are the orchestrator. Your job: turn human intent into approved tasks, then dispatch work.
 
-Tools available: deskfree_state, deskfree_propose, deskfree_send_message, deskfree_read_file, deskfree_update_file.
+**Main thread = short and snappy.** Keep responses to 1-3 sentences. Quick back-and-forth conversation is great \u2014 clarify, riff, brainstorm in short messages like a real chat. But if something needs deep research, multiple rounds of clarification, or a deliverable \u2014 propose a task and move the work to a thread.
 
----
+**The core loop: propose \u2192 approve \u2192 work.**
 
-### 1. REVIEW THE DAY
+1. **Check state** \u2192 \`deskfree_state\` \u2014 see tasks, memory (a pinned file with accumulated knowledge), and files.
+2. **Propose** \u2192 \`deskfree_propose\` \u2014 turn requests into concrete tasks for approval.
+3. **Dispatch** \u2192 \`deskfree_dispatch_worker\` with the taskId.
+4. **Communicate** \u2192 \`deskfree_send_message\` for updates outside task threads.
 
-Your prompt contains both \`<current_memory>\` (the current Memory file content) and \`<daily_observations>\` (raw daily logs) inline \u2014 you have everything you need upfront.
+**Before proposing, qualify the request.** Figure out what kind of thing this is:
+- **One-off task** ("proofread this") \u2192 propose a task directly.
+- **New aspiration** ("I want to start posting on LinkedIn") \u2192 don't rush to propose. Ask 1-2 short qualifying questions to understand the real goal.
+- Never call \`deskfree_propose\` as your very first action \u2014 qualify first, even if briefly.
 
-**Steps:**
-1. Review the current memory and daily observations from your prompt.
-2. Call \`deskfree_state\` to see the current board \u2014 open tasks, recently completed work, files.
-3. Build a mental model of what happened today: what was accomplished, what's in progress, what's stalled.
+**Match the human's energy.** Short message \u2192 short reply. Casual tone \u2192 casual response. Don't over-explain, don't lecture, don't pad responses.
 
-### 2. IDENTIFY OVERNIGHT OPPORTUNITIES
+You do NOT claim tasks, complete tasks, or do work directly \u2014 you have no access to deskfree_start_task or deskfree_complete_task. Use \`deskfree_dispatch_worker\` to dispatch a worker for each approved task.
+- When a human writes in a task thread, decide:
+  - **Continuation of the same task?** \u2192 reopen and dispatch a worker.
+  - **New/different work request?** \u2192 propose it as a new task (don't reopen the old one or do the work yourself).
+  - **Just confirmation or deferred?** \u2192 leave it for now.
+- Estimate token cost per task \u2014 consider files to read, reasoning, output.`;
+    DESKFREE_WORKER_DIRECTIVE = `## DeskFree Worker
+You are a worker sub-agent. Your first message contains pre-loaded context \u2014 use it directly.
+Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_complete_task, deskfree_send_message, deskfree_propose.
 
-Think about work that can be done autonomously overnight \u2014 WITHOUT human judgment or approval mid-task.
+**Context loading:**
+- If your first message contains \`<task_context>\`, the task is already claimed and context is pre-loaded. Do NOT call deskfree_start_task \u2014 start working immediately.
+- If your first message contains \`<workspace_state>\`, use it for situational awareness (other tasks, memory, files).
+- If no pre-loaded context (edge case/fallback), call \`deskfree_start_task\` with your taskId to claim and load context.
+- If continuing from a previous conversation (you can see prior tool calls and context), respond directly to the human's latest message \u2014 do NOT call deskfree_start_task again.
 
-**Good overnight work:**
-- Research and analysis (market research, competitive analysis, reading material)
-- Content drafts (blog posts, reports, documentation)
-- File updates (updating recurring reports, preparing templates)
-- Prep work for tomorrow (gathering context, pre-reading for scheduled meetings)
-- Recurring tasks that are due (weekly reviews, daily audits)
+**Orient \u2192 Align \u2192 Work.** Every new task follows this rhythm:
 
-**NOT good overnight work:**
-- Anything requiring human decisions mid-task
-- Tasks that depend on external input not yet received
-- Creative work where the human has strong opinions on direction
-- Anything the human explicitly said to wait on
+1. **Orient** \u2014 Scan workspace state for relevant files. Read the Memory file for context on preferences and past patterns. Read any other files that are useful context with \`deskfree_read_file\`. Don't read everything \u2014 just what's relevant to this task.
+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.
+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.
 
-### 3. PROPOSE THE PLAN
+**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.
+- You're a teammate, not a task executor. Have an opinion when you have the context to form one.
 
-If you identified useful overnight work:
-1. Use \`deskfree_propose\` with 1-3 well-scoped tasks. Quality over quantity.
-2. Each task should be self-contained \u2014 a worker must be able to complete it without human input.
-3. Set \`scheduledFor\` if work should start at a specific time (e.g. early morning).
-4. If nothing genuinely useful can be done overnight, skip the proposal entirely. Don't force it.
+**File rules:**
+- Create files when your task naturally produces them. Don't be afraid to create multiple files if the work calls for it.
+- Always pass \`taskId\` when creating or updating files \u2014 this threads notifications into the task.
+- If you discover work that falls outside your task's scope, use \`deskfree_propose\` to suggest follow-up tasks immediately \u2014 don't wait until completion. Propose as you discover, then stay focused on your current task.
 
-### 4. BRIEF THE HUMAN
+**Learnings:**
+- Use \`deskfree_learning\` to record observations worth remembering. A nightly sleep cycle consolidates these into the Memory file. Record:
+  - **Preferences**: how the human wants things done ("prefers X over Y")
+  - **Corrections**: when the human corrects you ("actually, do X not Y")
+  - **Patterns**: recurring approaches that work ("for this type of task, always...")
+  - **Domain facts**: business-specific knowledge not in project docs
+- Prefix critical observations with [!] (corrections, constraints, errors).
+- Prefix notable observations with [~] (preferences, patterns).
+- Leave routine observations unprefixed.
+- Do NOT record one-time task details, things in project docs, or obvious/generic knowledge.
+- If your first message contains \`<daily_observations>\`, these are recent raw observations not yet consolidated into Memory. Use them as additional context.
 
-Send a brief main-thread message via \`deskfree_send_message\`:
-- 2-3 sentence summary: what happened today + what you're proposing for overnight (if anything).
-- Keep it conversational and useful \u2014 this is the human's "end of day" touchpoint.
-- If no proposals, still send a brief day summary.
+**Sub-agents & delegation:**
+- Your context window is finite. Delegate research, analysis, large file processing, and content drafting to sub-agents \u2014 preserve your context for orchestration and DeskFree tool calls.
+- Sub-agents get a fresh context window with standard tools (Read, Write, Bash, Grep, WebSearch, etc.) but NO DeskFree tools. Pre-load any file content they need into the prompt.
+- Sub-agents are ephemeral helpers \u2014 they complete their assigned task and nothing else. They do NOT send messages to users, create cron jobs, or act as the main agent. Their final output is returned to you.
+- Use \`run_in_background: true\` for parallel independent work.
+- During Orient, check Memory for sub-agent helper patterns. Inject relevant ones into the sub-agent prompt alongside the task.
+- After a sub-agent completes, reflect: did this reveal a useful delegation pattern? Something to do differently? Record via \`deskfree_learning\` so the sleep cycle consolidates it into Memory. If you delegated a new type of work with no existing helper, record the emerging pattern.
+- Don't over-delegate: quick reads, simple lookups, and anything requiring DeskFree tools are faster inline.
 
-### Rules
-- Do NOT propose things already on the board or recently completed.
-- Do NOT repeat suggestions the human previously ignored or rejected.
-- Quality over quantity. One good task beats three mediocre ones.
-- Keep the briefing message short and actionable.
-- Cross-reference memory for recurring patterns \u2014 if something is due, propose it.
-- Use \`deskfree_read_file\` only if you need file content beyond what's in your prompt.`;
+**Completing tasks:**
+- On 409 or 404 errors: STOP. Do not retry. Call deskfree_state to find available tasks.`;
     THROTTLE_MS = 300;
     CHAR_BUFFER_SIZE = 256;
     CLOSE_MAX_RETRIES = 3;
@@ -7793,7 +8316,15 @@ Send a brief main-thread message via \`deskfree_send_message\`:
   }
 });
 function runOrchestrator(opts) {
-  const { prompt, orchestratorServer, model, sessionId, claudeCodePath } = opts;
+  const {
+    prompt,
+    orchestratorServer,
+    model,
+    sessionId,
+    claudeCodePath,
+    agentContext
+  } = opts;
+  const systemPrompt = agentContext ? buildAgentDirective(agentContext) : DESKFREE_AGENT_DIRECTIVE;
   return query({
     prompt,
     options: {
@@ -7801,7 +8332,7 @@ function runOrchestrator(opts) {
         process.stderr.write(`[orchestrator-sdk] ${data}
 `);
       },
-      systemPrompt: DESKFREE_AGENT_DIRECTIVE,
+      systemPrompt,
       model,
       ...claudeCodePath ? { pathToClaudeCodeExecutable: claudeCodePath } : {},
       maxTurns: MAX_ORCHESTRATOR_TURNS,
@@ -7814,28 +8345,18 @@ function runOrchestrator(opts) {
         "deskfree-orchestrator": orchestratorServer
       },
       tools: [],
-      allowedTools: [
-        "mcp__deskfree-orchestrator__*",
-        "Read",
-        "Write",
-        "Edit",
-        "Bash",
-        "Glob",
-        "Grep",
-        "WebSearch",
-        "WebFetch",
-        "NotebookEdit"
-      ],
+      allowedTools: ORCHESTRATOR_ALLOWED_TOOLS,
       disallowedTools: DISALLOWED_BUILTIN_TOOLS
     }
   });
 }
 function runHeartbeat(opts) {
-  const { prompt, orchestratorServer, model, claudeCodePath } = opts;
+  const { prompt, orchestratorServer, model, claudeCodePath, agentContext } = opts;
+  const systemPrompt = agentContext ? buildHeartbeatDirective(agentContext) : DESKFREE_AGENT_DIRECTIVE;
   return query({
     prompt,
     options: {
-      systemPrompt: DESKFREE_AGENT_DIRECTIVE,
+      systemPrompt,
       model,
       ...claudeCodePath ? { pathToClaudeCodeExecutable: claudeCodePath } : {},
       maxTurns: MAX_ORCHESTRATOR_TURNS,
@@ -7846,18 +8367,7 @@ function runHeartbeat(opts) {
         "deskfree-orchestrator": orchestratorServer
       },
       tools: [],
-      allowedTools: [
-        "mcp__deskfree-orchestrator__*",
-        "Read",
-        "Write",
-        "Edit",
-        "Bash",
-        "Glob",
-        "Grep",
-        "WebSearch",
-        "WebFetch",
-        "NotebookEdit"
-      ],
+      allowedTools: ORCHESTRATOR_ALLOWED_TOOLS,
       disallowedTools: DISALLOWED_BUILTIN_TOOLS
     }
   });
@@ -7880,11 +8390,19 @@ function runOneShotWorker(opts) {
     }
   });
 }
-var MAX_ORCHESTRATOR_TURNS, DISALLOWED_BUILTIN_TOOLS;
+var MAX_ORCHESTRATOR_TURNS, ORCHESTRATOR_ALLOWED_TOOLS, DISALLOWED_BUILTIN_TOOLS;
 var init_orchestrator = __esm({
   "src/agents/orchestrator.ts"() {
     init_dist();
     MAX_ORCHESTRATOR_TURNS = 20;
+    ORCHESTRATOR_ALLOWED_TOOLS = [
+      "mcp__deskfree-orchestrator__*",
+      "Read",
+      "Glob",
+      "Grep",
+      "WebSearch",
+      "WebFetch"
+    ];
     DISALLOWED_BUILTIN_TOOLS = [
       "TodoWrite",
       "AskUserQuestion",
@@ -7961,8 +8479,8 @@ function loadConfig() {
 function mergeWithRemoteConfig(local, remote) {
   const stateDirOverridden = !!process.env["DESKFREE_STATE_DIR"];
   const toolsDirOverridden = !!process.env["DESKFREE_TOOLS_DIR"];
-  const stateDir = stateDirOverridden ? local.stateDir : isDocker ? local.stateDir : `.deskfree/${remote.botId}/state`;
-  const toolsDir = toolsDirOverridden ? local.toolsDir : isDocker ? local.toolsDir : `.deskfree/${remote.botId}/tools`;
+  const stateDir = stateDirOverridden ? local.stateDir : isDocker ? local.stateDir : join(homedir(), ".deskfree", remote.botId, "state");
+  const toolsDir = toolsDirOverridden ? local.toolsDir : isDocker ? local.toolsDir : join(homedir(), ".deskfree", remote.botId, "tools");
   let claudeCodePath;
   if (remote.provider === "claude-code") {
     try {
@@ -7990,6 +8508,8 @@ function mergeWithRemoteConfig(local, remote) {
     anthropicApiKey: remote.anthropicApiKey,
     baseUrl: process.env["DESKFREE_BASE_URL"] ?? remote.baseUrl,
     botId: remote.botId,
+    botName: remote.botName,
+    deploymentType: remote.deploymentType,
     memoryFileId: remote.memoryFileId,
     sleepHour: remote.sleepHour,
     duskHour: remote.duskHour,
@@ -8002,8 +8522,8 @@ var init_config = __esm({
     init_dist();
     isDocker = process.env["DOCKER"] === "1" || existsSync("/.dockerenv");
     DEFAULTS = {
-      stateDir: isDocker ? "/app/state" : ".deskfree/state",
-      toolsDir: isDocker ? "/app/tools" : ".deskfree/tools",
+      stateDir: isDocker ? "/app/state" : join(homedir(), ".deskfree", "state"),
+      toolsDir: isDocker ? "/app/tools" : join(homedir(), ".deskfree", "tools"),
       logLevel: "info",
       healthPort: 3100
     };
@@ -8049,6 +8569,86 @@ var init_health_state = __esm({
   }
 });
 
+// src/util/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  createLogger: () => createLogger,
+  enableFileLogging: () => enableFileLogging,
+  getLogFilePath: () => getLogFilePath,
+  logger: () => logger
+});
+function enableFileLogging(filePath) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  logFilePath = filePath;
+}
+function getLogFilePath() {
+  return logFilePath;
+}
+function rotateIfNeeded() {
+  if (!logFilePath) return;
+  try {
+    const stat = statSync(logFilePath);
+    if (stat.size <= MAX_LOG_FILE_BYTES) return;
+    const content = readFileSync(logFilePath, "utf8");
+    const half = Math.floor(content.length / 2);
+    const newlineIdx = content.indexOf("\n", half);
+    const trimmed = newlineIdx >= 0 ? content.slice(newlineIdx + 1) : content.slice(half);
+    writeFileSync(logFilePath, trimmed);
+  } catch {
+  }
+}
+function createLogger(component, minLevel = "info") {
+  const minLevelNum = LEVELS[minLevel];
+  function log(level, message, fields) {
+    if (LEVELS[level] < minLevelNum) return;
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component,
+      msg: message,
+      ...fields
+    };
+    const line = JSON.stringify(entry);
+    if (level === "error" || level === "warn") {
+      process.stderr.write(line + "\n");
+    } else {
+      process.stdout.write(line + "\n");
+    }
+    if (logFilePath) {
+      try {
+        appendFileSync(logFilePath, line + "\n");
+        if (++writesSinceCheck >= ROTATION_CHECK_INTERVAL) {
+          writesSinceCheck = 0;
+          rotateIfNeeded();
+        }
+      } catch {
+      }
+    }
+  }
+  return {
+    debug: (msg, fields) => log("debug", msg, fields),
+    info: (msg, fields) => log("info", msg, fields),
+    warn: (msg, fields) => log("warn", msg, fields),
+    error: (msg, fields) => log("error", msg, fields)
+  };
+}
+var LEVELS, MAX_LOG_FILE_BYTES, ROTATION_CHECK_INTERVAL, logFilePath, writesSinceCheck, logger;
+var init_logger = __esm({
+  "src/util/logger.ts"() {
+    LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    MAX_LOG_FILE_BYTES = 5 * 1024 * 1024;
+    ROTATION_CHECK_INTERVAL = 500;
+    logFilePath = null;
+    writesSinceCheck = 0;
+    logger = createLogger("runtime");
+  }
+});
+
 // src/gateway/polling.ts
 async function pollAndDeliver(client, accountId, stateDir, cursor, onMessage, log) {
   const ctx = { accountId };
@@ -11753,8 +12353,6 @@ var init_wrapper = __esm({
     wrapper_default2 = import_websocket2.default;
   }
 });
-
-// src/gateway/ws-gateway.ts
 function nextBackoff(state2) {
   const delay = Math.min(
     BACKOFF_INITIAL_MS * Math.pow(BACKOFF_FACTOR, state2.attempt),
@@ -11934,11 +12532,11 @@ async function runWebSocketConnection(opts) {
       }, PING_INTERVAL_MS);
       if (opts.getWorkerStatus) {
         try {
-          const status = opts.getWorkerStatus();
+          const status2 = opts.getWorkerStatus();
           ws.send(
             JSON.stringify({
               action: "heartbeatResponse",
-              ...status
+              ...status2
             })
           );
         } catch (err) {
@@ -12008,11 +12606,11 @@ async function runWebSocketConnection(opts) {
         } else if (msg.action === "heartbeatRequest") {
           if (opts.getWorkerStatus && ws.readyState === wrapper_default2.OPEN) {
             try {
-              const status = opts.getWorkerStatus();
+              const status2 = opts.getWorkerStatus();
               ws.send(
                 JSON.stringify({
                   action: "heartbeatResponse",
-                  ...status
+                  ...status2
                 })
               );
             } catch (err) {
@@ -12027,6 +12625,49 @@ async function runWebSocketConnection(opts) {
           cleanup();
           ws.close(1e3, "reload");
           process.kill(process.pid, "SIGTERM");
+        } else if (msg.action === "logs") {
+          const MAX_RESPONSE_BYTES = 12e4;
+          const lineCount = msg.lines ?? 200;
+          try {
+            const logFile = getLogFilePath();
+            if (!logFile) {
+              ws.send(
+                JSON.stringify({
+                  action: "logsResponse",
+                  lines: [],
+                  error: "File logging not enabled"
+                })
+              );
+            } else {
+              const content = readFileSync(logFile, "utf8");
+              const allLines = content.split("\n").filter(Boolean);
+              let tail = allLines.slice(-lineCount);
+              while (tail.length > 1) {
+                const payload = JSON.stringify({
+                  action: "logsResponse",
+                  lines: tail
+                });
+                if (Buffer.byteLength(payload) <= MAX_RESPONSE_BYTES) break;
+                tail = tail.slice(Math.ceil(tail.length * 0.25));
+              }
+              ws.send(
+                JSON.stringify({
+                  action: "logsResponse",
+                  lines: tail
+                })
+              );
+            }
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log.warn(`Failed to read logs: ${errMsg}`);
+            ws.send(
+              JSON.stringify({
+                action: "logsResponse",
+                lines: [],
+                error: errMsg
+              })
+            );
+          }
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -12145,6 +12786,7 @@ var PING_INTERVAL_MS, POLL_FALLBACK_INTERVAL_MS, WS_CONNECTION_TIMEOUT_MS, WS_PO
 var init_ws_gateway = __esm({
   "src/gateway/ws-gateway.ts"() {
     init_health_state();
+    init_logger();
     init_polling();
     init_dist();
     init_wrapper();
@@ -12639,21 +13281,35 @@ function scheduleDailyCycle(label, run, hour, timezone, signal, log) {
 }
 function msUntilNextLocalHour(hour, timezone) {
   const now = Date.now();
-  const fmt = new Intl.DateTimeFormat("en-US", {
+  const hourFmt = new Intl.DateTimeFormat("en-US", {
     timeZone: timezone,
     hour: "numeric",
     hour12: false
   });
+  const detailFmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    minute: "numeric",
+    second: "numeric"
+  });
   for (let offsetMs = 6e4; offsetMs <= 25 * 36e5; offsetMs += 36e5) {
     const candidateMs = now + offsetMs;
-    const parts = fmt.formatToParts(new Date(candidateMs));
+    const parts = hourFmt.formatToParts(new Date(candidateMs));
     const hourPart = parts.find((p) => p.type === "hour");
     const candidateHour = parseInt(hourPart?.value ?? "-1", 10);
     if (candidateHour === hour) {
-      const candidate = new Date(candidateMs);
-      candidate.setUTCMinutes(0, 0, 0);
-      const snappedMs = candidate.getTime();
-      return Math.max(snappedMs - now, 6e4);
+      const detailParts = detailFmt.formatToParts(new Date(candidateMs));
+      const localMinute = parseInt(
+        detailParts.find((p) => p.type === "minute")?.value ?? "0",
+        10
+      );
+      const localSecond = parseInt(
+        detailParts.find((p) => p.type === "second")?.value ?? "0",
+        10
+      );
+      const snappedMs = candidateMs - localMinute * 6e4 - localSecond * 1e3;
+      if (snappedMs > now + 6e4) {
+        return snappedMs - now;
+      }
     }
   }
   return 24 * 36e5;
@@ -12749,50 +13405,6 @@ var init_registry = __esm({
   "src/tools/registry.ts"() {
   }
 });
-
-// src/util/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
-  createLogger: () => createLogger,
-  logger: () => logger
-});
-function createLogger(component, minLevel = "info") {
-  const minLevelNum = LEVELS[minLevel];
-  function log(level, message, fields) {
-    if (LEVELS[level] < minLevelNum) return;
-    const entry = {
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      component,
-      msg: message,
-      ...fields
-    };
-    const line = JSON.stringify(entry);
-    if (level === "error" || level === "warn") {
-      process.stderr.write(line + "\n");
-    } else {
-      process.stdout.write(line + "\n");
-    }
-  }
-  return {
-    debug: (msg, fields) => log("debug", msg, fields),
-    info: (msg, fields) => log("info", msg, fields),
-    warn: (msg, fields) => log("warn", msg, fields),
-    error: (msg, fields) => log("error", msg, fields)
-  };
-}
-var LEVELS, logger;
-var init_logger = __esm({
-  "src/util/logger.ts"() {
-    LEVELS = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3
-    };
-    logger = createLogger("runtime");
-  }
-});
 function checkRateLimit(userId) {
   const now = Date.now();
   const entry = rateLimitMap.get(userId);
@@ -13057,7 +13669,8 @@ async function routeMessage(message, client, deps, sessionStore, config) {
       orchestratorServer: deps.createOrchestratorServer(),
       model: deps.model,
       sessionId: existingSessionId,
-      claudeCodePath: deps.claudeCodePath
+      claudeCodePath: deps.claudeCodePath,
+      agentContext: deps.agentContext
     });
     let fullText = "";
     let capturedSessionId = null;
@@ -13240,17 +13853,16 @@ var init_sessions = __esm({
   }
 });
 function runWorker(opts) {
-  const { prompt, workerServer, model, sessionId } = opts;
+  const { prompt, workerServer, model, sessionId, agentContext } = opts;
+  const systemPrompt = agentContext ? buildWorkerDirective(agentContext) : DESKFREE_WORKER_DIRECTIVE;
   return query({
     prompt,
     options: {
-      debug: true,
-      debugFile: "/dev/stderr",
       stderr: (data) => {
         process.stderr.write(`[worker-sdk] ${data}
 `);
       },
-      systemPrompt: DESKFREE_WORKER_DIRECTIVE,
+      systemPrompt,
       model,
       maxTurns: MAX_WORKER_TURNS,
       permissionMode: "bypassPermissions",
@@ -13562,7 +14174,8 @@ ${userMessage}
           prompt: channel,
           workerServer,
           model,
-          sessionId: previousSessionId
+          sessionId: previousSessionId,
+          agentContext: this.deps.agentContext
         });
         const idleTimer = this.startIdleTimer(taskId);
         const drainPromise = this.drainLoop(
@@ -13808,7 +14421,7 @@ function startHealthServer(port, log) {
     }
   };
 }
-function scheduleHeartbeat(createOrchServer, model, intervalMs, signal, log, claudeCodePath) {
+function scheduleHeartbeat(createOrchServer, model, intervalMs, signal, log, claudeCodePath, agentContext) {
   if (intervalMs <= 0) return;
   let running = false;
   async function tick() {
@@ -13816,11 +14429,13 @@ function scheduleHeartbeat(createOrchServer, model, intervalMs, signal, log, cla
     running = true;
     try {
       log.debug("Heartbeat tick: checking for pending work...");
+      const heartbeatPrompt = agentContext ? buildHeartbeatDirective(agentContext) : "Run your heartbeat check now.";
       const result = runHeartbeat({
-        prompt: DESKFREE_HEARTBEAT_DIRECTIVE,
+        prompt: heartbeatPrompt,
         orchestratorServer: createOrchServer(),
         model,
-        claudeCodePath
+        claudeCodePath,
+        agentContext
       });
       for await (const _ of result) {
       }
@@ -13861,8 +14476,23 @@ async function startAgent(opts) {
     const msg = err instanceof Error ? err.message : String(err);
     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,
+    provider: config.provider,
+    model: config.model,
+    platform: isDocker2 ? "Docker" : process.platform === "darwin" ? "macOS" : "Linux",
+    runtimeVersion,
+    maxConcurrentWorkers: 5
+    // updated after WorkerManager is created
+  };
   mkdirSync(config.stateDir, { recursive: true });
   mkdirSync(config.toolsDir, { recursive: true });
+  const logFile = join(config.stateDir, "runtime.log");
+  enableFileLogging(logFile);
+  log.info(`File logging enabled: ${logFile}`);
   if (config.tools.length > 0) {
     log.info(`Installing ${config.tools.length} tool package(s)...`);
     await installTools(config.tools, config.toolsDir, log);
@@ -13916,8 +14546,10 @@ async function startAgent(opts) {
       "memory",
       config.botId,
       "session-history.json"
-    )
+    ),
+    agentContext
   });
+  agentContext.maxConcurrentWorkers = workerManager.maxConcurrentWorkers;
   const createOrchServer = () => createOrchestratorMcpServer(client, customTools, workerManager);
   const healthServer = startHealthServer(config.healthPort, log);
   const sessionStore = new SessionStore();
@@ -13944,7 +14576,8 @@ async function startAgent(opts) {
           createOrchestratorServer: createOrchServer,
           workerManager,
           model: config.model,
-          claudeCodePath: config.claudeCodePath
+          claudeCodePath: config.claudeCodePath,
+          agentContext
         },
         sessionStore,
         {
@@ -13960,7 +14593,8 @@ async function startAgent(opts) {
     config.heartbeatIntervalMs,
     abortController.signal,
     log,
-    config.claudeCodePath
+    config.claudeCodePath,
+    agentContext
   );
   if (config.memoryFileId && config.sleepHour !== null && config.timezone) {
     const memoryFileId = config.memoryFileId;
@@ -13997,7 +14631,7 @@ async function startAgent(opts) {
         const workerServer = createWorkServer();
         const result = runOneShotWorker({
           prompt,
-          systemPrompt: DESKFREE_SLEEP_DIRECTIVE,
+          systemPrompt: buildSleepDirective(agentContext),
           workerServer,
           model: config.model
         });
@@ -14043,7 +14677,7 @@ async function startAgent(opts) {
         const workerServer = createWorkServer();
         const result = runOneShotWorker({
           prompt,
-          systemPrompt: DESKFREE_DUSK_DIRECTIVE,
+          systemPrompt: buildDuskDirective(agentContext),
           workerServer,
           model: config.model
         });
@@ -14093,16 +14727,42 @@ var init_entrypoint = __esm({
 var args = process.argv.slice(2);
 var command = args[0];
 if (command === "install") {
-  const token = args[1];
+  let token = args[1];
   if (!token) {
-    console.error("Usage: deskfree-agent install <token>");
-    process.exit(1);
+    const { createInterface } = await import('readline');
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    token = await new Promise((resolve) => {
+      rl.question(
+        "Paste your bot token (from the DeskFree dashboard):\n> ",
+        (answer) => {
+          rl.close();
+          resolve(answer.trim());
+        }
+      );
+    });
+    if (!token) {
+      console.error("No token provided.");
+      process.exit(1);
+    }
   }
   const { install: install2 } = await Promise.resolve().then(() => (init_install(), install_exports));
   install2(token);
 } else if (command === "uninstall") {
   const { uninstall: uninstall2 } = await Promise.resolve().then(() => (init_uninstall(), uninstall_exports));
   uninstall2();
+} else if (command === "status") {
+  const { status: status2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+  status2();
+} else if (command === "restart") {
+  const { restart: restart2 } = await Promise.resolve().then(() => (init_restart(), restart_exports));
+  restart2();
+} else if (command === "logs") {
+  const follow = args.includes("-f") || args.includes("--follow");
+  const { logs: logs2 } = await Promise.resolve().then(() => (init_logs(), logs_exports));
+  logs2(follow);
 } else {
   let handleShutdown = function(signal) {
     log.info(`Received ${signal} \u2014 shutting down...`);