@questionbase/deskfree 0.4.7 → 0.5.1

package/dist/bin.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { 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 { spawn, execSync, execFileSync, execFile } from 'child_process';
+import { mkdirSync, writeFileSync, chmodSync, existsSync, unlinkSync, appendFileSync, readdirSync, readFileSync, statSync, createWriteStream } from 'fs';
 import { createRequire as createRequire$1 } from 'module';
 import { query, createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
@@ -33,8 +33,8 @@ var __commonJS = (cb, mod) => function __require3() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -52,25 +52,66 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   __defProp(target, "default", { value: mod, enumerable: true }) ,
   mod
 ));
-
-// src/cli/install.ts
-var install_exports = {};
-__export(install_exports, {
-  install: () => install
-});
-function getMacPaths() {
+function getPlistLabel(name2) {
+  return `com.deskfree.agent.${name2}`;
+}
+function getServiceName(name2) {
+  return `deskfree-agent-${name2}`;
+}
+function getMacPaths(name2) {
   const home = homedir();
-  const deskfreeDir = join(home, ".deskfree");
+  const deskfreeDir = join(home, ".deskfree", name2);
+  const plistLabel = getPlistLabel(name2);
   return {
     deskfreeDir,
     envFile: join(deskfreeDir, ".env"),
     launcher: join(deskfreeDir, "launcher.sh"),
     logDir: join(deskfreeDir, "logs"),
-    plist: join(home, "Library", "LaunchAgents", `${PLIST_LABEL}.plist`)
+    plist: join(home, "Library", "LaunchAgents", `${plistLabel}.plist`)
+  };
+}
+function getLinuxPaths(name2) {
+  const serviceName = getServiceName(name2);
+  return {
+    serviceName,
+    serviceFile: `/etc/systemd/system/${serviceName}.service`,
+    envFile: `/etc/${serviceName}.env`,
+    stateDir: `/var/lib/${serviceName}`,
+    logDir: `/var/log/${serviceName}`
   };
 }
-function installMac(token) {
-  const paths = getMacPaths();
+function parseName(args) {
+  const idx = args.indexOf("--name");
+  if (idx === -1) return [DEFAULT_NAME, args];
+  const name2 = args[idx + 1];
+  if (!name2 || name2.startsWith("-")) {
+    console.error("Error: --name requires a value (e.g. --name kasper)");
+    process.exit(1);
+  }
+  if (!/^[a-z0-9-]+$/i.test(name2)) {
+    console.error(
+      "Error: --name must contain only letters, numbers, and hyphens"
+    );
+    process.exit(1);
+  }
+  const remaining = [...args.slice(0, idx), ...args.slice(idx + 2)];
+  return [name2, remaining];
+}
+var DEFAULT_NAME;
+var init_paths = __esm({
+  "src/cli/paths.ts"() {
+    DEFAULT_NAME = "main";
+  }
+});
+
+// src/cli/install.ts
+var install_exports = {};
+__export(install_exports, {
+  install: () => install
+});
+function installMac(token, name2) {
+  const paths = getMacPaths(name2);
+  const plistLabel = getPlistLabel(name2);
   let nodeBinDir;
   try {
     const nodePath = execSync("which node", { encoding: "utf8" }).trim();
@@ -82,8 +123,13 @@ function installMac(token) {
   mkdirSync(paths.deskfreeDir, { recursive: true });
   mkdirSync(paths.logDir, { recursive: true });
   mkdirSync(dirname(paths.plist), { recursive: true });
-  writeFileSync(paths.envFile, `DESKFREE_LAUNCH=${token}
-`, { mode: 384 });
+  writeFileSync(
+    paths.envFile,
+    `DESKFREE_LAUNCH=${token}
+DESKFREE_INSTANCE_NAME=${name2}
+`,
+    { mode: 384 }
+  );
   chmodSync(paths.envFile, 384);
   console.log(`Wrote ${paths.envFile}`);
   const launcher = `#!/bin/bash
@@ -109,7 +155,7 @@ exec deskfree-agent start
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>${PLIST_LABEL}</string>
+  <string>${plistLabel}</string>
   <key>ProgramArguments</key>
   <array>
     <string>${paths.launcher}</string>
@@ -137,72 +183,100 @@ exec deskfree-agent start
   }
   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}`);
+Service ${plistLabel} installed and started.`);
+  console.log(`Check status: launchctl print gui/$(id -u)/${plistLabel}`);
   console.log(`Logs: tail -f ${join(paths.logDir, "stdout.log")}`);
 }
-function installLinux(token) {
+function installLinux(token, name2) {
   if (process.getuid?.() !== 0) {
     console.error("Error: install must be run as root (use sudo)");
     process.exit(1);
   }
-  let npxPath;
+  const paths = getLinuxPaths(name2);
+  const serviceName = getServiceName(name2);
+  const systemUser = serviceName;
+  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(SYSTEMD_ENV_FILE, `DESKFREE_LAUNCH=${token}
-`, {
-    mode: 384
-  });
-  chmodSync(SYSTEMD_ENV_FILE, 384);
-  console.log(`Wrote ${SYSTEMD_ENV_FILE}`);
+  try {
+    execSync(`id ${systemUser}`, { stdio: "ignore" });
+  } catch {
+    execSync(
+      `useradd --system --no-create-home --shell /usr/sbin/nologin ${systemUser}`
+    );
+    console.log(`Created system user: ${systemUser}`);
+  }
+  mkdirSync(paths.stateDir, { recursive: true });
+  mkdirSync(paths.logDir, { recursive: true });
+  execSync(
+    `chown ${systemUser}:${systemUser} ${paths.stateDir} ${paths.logDir}`
+  );
+  console.log(`Created ${paths.stateDir} and ${paths.logDir}`);
+  writeFileSync(
+    paths.envFile,
+    `DESKFREE_LAUNCH=${token}
+DESKFREE_INSTANCE_NAME=${name2}
+`,
+    { mode: 384 }
+  );
+  chmodSync(paths.envFile, 384);
+  console.log(`Wrote ${paths.envFile}`);
   const unit = `[Unit]
-Description=DeskFree Agent
+Description=DeskFree Agent (${name2})
 After=network-online.target
 Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStartPre=${npxPath} ${PACKAGE} --version
-ExecStart=${npxPath} ${PACKAGE} start
-EnvironmentFile=${SYSTEMD_ENV_FILE}
+User=${systemUser}
+Group=${systemUser}
+WorkingDirectory=${paths.stateDir}
+Environment=PATH=${nodeBinDir}:/usr/local/bin:/usr/bin:/bin
+ExecStartPre=+${npmPath} install -g ${PACKAGE}
+ExecStart=${nodeBinDir}/deskfree-agent start
+EnvironmentFile=${paths.envFile}
 Environment=NODE_ENV=production
+Environment=DESKFREE_STATE_DIR=${paths.stateDir}
+Environment=DESKFREE_TOOLS_DIR=${paths.stateDir}/tools
 Restart=always
 RestartSec=10
+StandardOutput=append:${paths.logDir}/stdout.log
+StandardError=append:${paths.logDir}/stderr.log
 
 [Install]
 WantedBy=multi-user.target
 `;
-  writeFileSync(SYSTEMD_SERVICE_FILE, unit);
-  console.log(`Wrote ${SYSTEMD_SERVICE_FILE}`);
+  writeFileSync(paths.serviceFile, unit);
+  console.log(`Wrote ${paths.serviceFile}`);
   execSync("systemctl daemon-reload");
-  execSync(`systemctl enable ${SERVICE_NAME}`);
-  execSync(`systemctl start ${SERVICE_NAME}`);
+  execSync(`systemctl enable ${serviceName}`);
+  execSync(`systemctl start ${serviceName}`);
   console.log(`
-Service ${SERVICE_NAME} installed and started.`);
-  console.log(`Check status: systemctl status ${SERVICE_NAME}`);
+Service ${serviceName} installed and started.`);
+  console.log(`Check status: systemctl status ${serviceName}`);
+  console.log(`Logs: tail -f ${paths.logDir}/stdout.log`);
 }
-function install(token) {
+function install(token, name2) {
   if (process.platform === "darwin") {
-    installMac(token);
+    installMac(token, name2);
   } else if (process.platform === "linux") {
-    installLinux(token);
+    installLinux(token, name2);
   } else {
     console.error(`Unsupported platform: ${process.platform}`);
     process.exit(1);
   }
 }
-var SERVICE_NAME, PACKAGE, PLIST_LABEL, SYSTEMD_SERVICE_FILE, SYSTEMD_ENV_FILE;
+var PACKAGE;
 var init_install = __esm({
   "src/cli/install.ts"() {
-    SERVICE_NAME = "deskfree-agent";
+    init_paths();
     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`;
   }
 });
 
@@ -211,68 +285,65 @@ var uninstall_exports = {};
 __export(uninstall_exports, {
   uninstall: () => 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");
+function uninstallMac(name2) {
+  const paths = getMacPaths(name2);
+  const plistLabel = getPlistLabel(name2);
   try {
-    execSync(`launchctl bootout gui/$(id -u) ${plist}`, { stdio: "ignore" });
+    execSync(`launchctl bootout gui/$(id -u) ${paths.plist}`, {
+      stdio: "ignore"
+    });
   } catch {
   }
-  for (const file of [plist, envFile, launcher]) {
+  for (const file of [paths.plist, paths.envFile, paths.launcher]) {
     if (existsSync(file)) {
       unlinkSync(file);
       console.log(`Removed ${file}`);
     }
   }
-  console.log(`Service ${PLIST_LABEL2} uninstalled.`);
+  console.log(`Service ${plistLabel} uninstalled.`);
   console.log(
-    `Note: logs and state in ${deskfreeDir} were preserved. Remove manually if desired.`
+    `Note: logs and state in ${paths.deskfreeDir} were preserved. Remove manually if desired.`
   );
 }
-function uninstallLinux() {
+function uninstallLinux(name2) {
   if (process.getuid?.() !== 0) {
     console.error("Error: uninstall must be run as root (use sudo)");
     process.exit(1);
   }
+  const paths = getLinuxPaths(name2);
+  const serviceName = getServiceName(name2);
   try {
-    execSync(`systemctl stop ${SERVICE_NAME2}`, { stdio: "ignore" });
+    execSync(`systemctl stop ${serviceName}`, { stdio: "ignore" });
   } catch {
   }
   try {
-    execSync(`systemctl disable ${SERVICE_NAME2}`, { stdio: "ignore" });
+    execSync(`systemctl disable ${serviceName}`, { stdio: "ignore" });
   } catch {
   }
-  if (existsSync(SYSTEMD_SERVICE_FILE2)) {
-    unlinkSync(SYSTEMD_SERVICE_FILE2);
-    console.log(`Removed ${SYSTEMD_SERVICE_FILE2}`);
+  if (existsSync(paths.serviceFile)) {
+    unlinkSync(paths.serviceFile);
+    console.log(`Removed ${paths.serviceFile}`);
   }
-  if (existsSync(SYSTEMD_ENV_FILE2)) {
-    unlinkSync(SYSTEMD_ENV_FILE2);
-    console.log(`Removed ${SYSTEMD_ENV_FILE2}`);
+  if (existsSync(paths.envFile)) {
+    unlinkSync(paths.envFile);
+    console.log(`Removed ${paths.envFile}`);
   }
   execSync("systemctl daemon-reload");
-  console.log(`Service ${SERVICE_NAME2} uninstalled.`);
+  console.log(`Service ${serviceName} uninstalled.`);
 }
-function uninstall() {
+function uninstall(name2) {
   if (process.platform === "darwin") {
-    uninstallMac();
+    uninstallMac(name2);
   } else if (process.platform === "linux") {
-    uninstallLinux();
+    uninstallLinux(name2);
   } 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";
-    PLIST_LABEL2 = "com.deskfree.agent";
-    SYSTEMD_SERVICE_FILE2 = `/etc/systemd/system/${SERVICE_NAME2}.service`;
-    SYSTEMD_ENV_FILE2 = `/etc/${SERVICE_NAME2}.env`;
+    init_paths();
   }
 });
 
@@ -281,44 +352,46 @@ 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: npx @questionbase/deskfree@latest install <token>`);
+function statusMac(name2) {
+  const paths = getMacPaths(name2);
+  const plistLabel = getPlistLabel(name2);
+  if (!existsSync(paths.plist)) {
+    console.log(`DeskFree Agent "${name2}" is not installed.`);
+    console.log(`Run: deskfree-agent install <token> --name ${name2}`);
     return;
   }
-  console.log("DeskFree Agent (macOS LaunchAgent)\n");
+  console.log(`DeskFree Agent "${name2}" (macOS LaunchAgent)
+`);
   try {
-    const output = execSync(
-      `launchctl print gui/$(id -u)/${PLIST_LABEL3} 2>&1`,
-      { encoding: "utf8" }
-    );
+    const output = execSync(`launchctl print gui/$(id -u)/${plistLabel} 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}`);
+    console.log(`  Logs: ${paths.logDir}/stdout.log`);
+    console.log(`  Plist: ${paths.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>`);
+function statusLinux(name2) {
+  const paths = getLinuxPaths(name2);
+  const serviceName = getServiceName(name2);
+  if (!existsSync(paths.serviceFile)) {
+    console.log(`DeskFree Agent "${name2}" is not installed.`);
+    console.log(
+      `Run: sudo npx @questionbase/deskfree@latest install <token> --name ${name2}`
+    );
     return;
   }
-  console.log("DeskFree Agent (systemd service)\n");
+  console.log(`DeskFree Agent "${name2}" (systemd service)
+`);
   try {
-    const output = execSync(
-      `systemctl status ${SYSTEMD_SERVICE_NAME} --no-pager 2>&1`,
-      { encoding: "utf8" }
-    );
+    const output = execSync(`systemctl status ${serviceName} --no-pager 2>&1`, {
+      encoding: "utf8"
+    });
     console.log(output);
   } catch (err) {
     if (err && typeof err === "object" && "stdout" in err) {
@@ -327,22 +400,116 @@ function statusLinux() {
       console.log("  Status: unknown (could not query systemd)");
     }
   }
+  console.log(`  Logs: ${paths.logDir}/stdout.log`);
 }
-function status() {
+function status(name2) {
   if (process.platform === "darwin") {
-    statusMac();
+    statusMac(name2);
   } else if (process.platform === "linux") {
-    statusLinux();
+    statusLinux(name2);
   } 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";
+    init_paths();
+  }
+});
+
+// src/cli/restart.ts
+var restart_exports = {};
+__export(restart_exports, {
+  restart: () => restart
+});
+function restartMac(name2) {
+  const paths = getMacPaths(name2);
+  if (!existsSync(paths.plist)) {
+    console.error(`DeskFree Agent "${name2}" is not installed.`);
+    console.error(`Run: deskfree-agent install <token> --name ${name2}`);
+    process.exit(1);
+  }
+  try {
+    execSync(`launchctl bootout gui/$(id -u) ${paths.plist}`, {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  execSync(`launchctl bootstrap gui/$(id -u) ${paths.plist}`);
+  console.log(`DeskFree Agent "${name2}" restarted.`);
+  console.log(`Logs: tail -f ${paths.logDir}/stdout.log`);
+}
+function restartLinux(name2) {
+  const paths = getLinuxPaths(name2);
+  const serviceName = getServiceName(name2);
+  if (!existsSync(paths.serviceFile)) {
+    console.error(`DeskFree Agent "${name2}" is not installed.`);
+    console.error(
+      `Run: sudo npx @questionbase/deskfree@latest install <token> --name ${name2}`
+    );
+    process.exit(1);
+  }
+  execSync(`systemctl restart ${serviceName}`, { stdio: "inherit" });
+  console.log(`DeskFree Agent "${name2}" restarted.`);
+  console.log(`Logs: tail -f ${paths.logDir}/stdout.log`);
+}
+function restart(name2) {
+  if (process.platform === "darwin") {
+    restartMac(name2);
+  } else if (process.platform === "linux") {
+    restartLinux(name2);
+  } else {
+    console.error(`Unsupported platform: ${process.platform}`);
+    process.exit(1);
+  }
+}
+var init_restart = __esm({
+  "src/cli/restart.ts"() {
+    init_paths();
+  }
+});
+
+// src/cli/logs.ts
+var logs_exports = {};
+__export(logs_exports, {
+  logs: () => logs
+});
+function getLogPath(name2) {
+  if (process.platform === "darwin") {
+    const logFile = join(getMacPaths(name2).logDir, "stdout.log");
+    return existsSync(logFile) ? logFile : null;
+  } else if (process.platform === "linux") {
+    const logFile = join(getLinuxPaths(name2).logDir, "stdout.log");
+    return existsSync(logFile) ? logFile : null;
+  }
+  return null;
+}
+function logs(follow, name2) {
+  if (process.platform !== "darwin" && process.platform !== "linux") {
+    console.error(`Unsupported platform: ${process.platform}`);
+    process.exit(1);
+  }
+  const logPath = getLogPath(name2);
+  if (!logPath) {
+    console.error(
+      `No log file found for "${name2}". Is DeskFree Agent installed with --name ${name2}?`
+    );
+    process.exit(1);
+  }
+  const args = follow ? ["-f", "-n", "50", logPath] : ["-n", "50", logPath];
+  const child = spawn("tail", args, { 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"() {
+    init_paths();
   }
 });
 function toErrorMessage(error) {
@@ -1373,8 +1540,8 @@ function Intersect(types, options) {
     throw new Error("Cannot intersect transform types");
   return IntersectCreate(types, options);
 }
-function Ref(...args2) {
-  const [$ref, options] = typeof args2[0] === "string" ? [args2[0], args2[1]] : [args2[0].$id, args2[1]];
+function Ref(...args) {
+  const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
   if (typeof $ref !== "string")
     throw new TypeBoxError("Ref: $ref must be a string");
   return CreateType({ [Kind]: "Ref", $ref }, options);
@@ -1933,78 +2100,78 @@ function RecordKey2(type) {
 function RecordValue2(type) {
   return type.patternProperties[RecordPattern(type)];
 }
-function FromConstructor2(args2, type) {
-  type.parameters = FromTypes(args2, type.parameters);
-  type.returns = FromType(args2, type.returns);
+function FromConstructor2(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
   return type;
 }
-function FromFunction2(args2, type) {
-  type.parameters = FromTypes(args2, type.parameters);
-  type.returns = FromType(args2, type.returns);
+function FromFunction2(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
   return type;
 }
-function FromIntersect5(args2, type) {
-  type.allOf = FromTypes(args2, type.allOf);
+function FromIntersect5(args, type) {
+  type.allOf = FromTypes(args, type.allOf);
   return type;
 }
-function FromUnion7(args2, type) {
-  type.anyOf = FromTypes(args2, type.anyOf);
+function FromUnion7(args, type) {
+  type.anyOf = FromTypes(args, type.anyOf);
   return type;
 }
-function FromTuple4(args2, type) {
+function FromTuple4(args, type) {
   if (IsUndefined(type.items))
     return type;
-  type.items = FromTypes(args2, type.items);
+  type.items = FromTypes(args, type.items);
   return type;
 }
-function FromArray5(args2, type) {
-  type.items = FromType(args2, type.items);
+function FromArray5(args, type) {
+  type.items = FromType(args, type.items);
   return type;
 }
-function FromAsyncIterator2(args2, type) {
-  type.items = FromType(args2, type.items);
+function FromAsyncIterator2(args, type) {
+  type.items = FromType(args, type.items);
   return type;
 }
-function FromIterator2(args2, type) {
-  type.items = FromType(args2, type.items);
+function FromIterator2(args, type) {
+  type.items = FromType(args, type.items);
   return type;
 }
-function FromPromise3(args2, type) {
-  type.item = FromType(args2, type.item);
+function FromPromise3(args, type) {
+  type.item = FromType(args, type.item);
   return type;
 }
-function FromObject2(args2, type) {
-  const mappedProperties = FromProperties11(args2, type.properties);
+function FromObject2(args, type) {
+  const mappedProperties = FromProperties11(args, type.properties);
   return { ...type, ...Object2(mappedProperties) };
 }
-function FromRecord2(args2, type) {
-  const mappedKey = FromType(args2, RecordKey2(type));
-  const mappedValue = FromType(args2, RecordValue2(type));
+function FromRecord2(args, type) {
+  const mappedKey = FromType(args, RecordKey2(type));
+  const mappedValue = FromType(args, RecordValue2(type));
   const result = Record(mappedKey, mappedValue);
   return { ...type, ...result };
 }
-function FromArgument(args2, argument) {
-  return argument.index in args2 ? args2[argument.index] : Unknown();
+function FromArgument(args, argument) {
+  return argument.index in args ? args[argument.index] : Unknown();
 }
-function FromProperty2(args2, type) {
+function FromProperty2(args, type) {
   const isReadonly = IsReadonly(type);
   const isOptional = IsOptional(type);
-  const mapped = FromType(args2, type);
+  const mapped = FromType(args, type);
   return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
 }
-function FromProperties11(args2, properties) {
+function FromProperties11(args, properties) {
   return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
-    return { ...result, [key]: FromProperty2(args2, properties[key]) };
+    return { ...result, [key]: FromProperty2(args, properties[key]) };
   }, {});
 }
-function FromTypes(args2, types) {
-  return types.map((type) => FromType(args2, type));
+function FromTypes(args, types) {
+  return types.map((type) => FromType(args, type));
 }
-function FromType(args2, type) {
-  return IsConstructor(type) ? FromConstructor2(args2, type) : IsFunction2(type) ? FromFunction2(args2, type) : IsIntersect(type) ? FromIntersect5(args2, type) : IsUnion(type) ? FromUnion7(args2, type) : IsTuple(type) ? FromTuple4(args2, type) : IsArray3(type) ? FromArray5(args2, type) : IsAsyncIterator2(type) ? FromAsyncIterator2(args2, type) : IsIterator2(type) ? FromIterator2(args2, type) : IsPromise(type) ? FromPromise3(args2, type) : IsObject3(type) ? FromObject2(args2, type) : IsRecord(type) ? FromRecord2(args2, type) : IsArgument(type) ? FromArgument(args2, type) : type;
+function FromType(args, type) {
+  return IsConstructor(type) ? FromConstructor2(args, type) : IsFunction2(type) ? FromFunction2(args, type) : IsIntersect(type) ? FromIntersect5(args, type) : IsUnion(type) ? FromUnion7(args, type) : IsTuple(type) ? FromTuple4(args, type) : IsArray3(type) ? FromArray5(args, type) : IsAsyncIterator2(type) ? FromAsyncIterator2(args, type) : IsIterator2(type) ? FromIterator2(args, type) : IsPromise(type) ? FromPromise3(args, type) : IsObject3(type) ? FromObject2(args, type) : IsRecord(type) ? FromRecord2(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
 }
-function Instantiate(type, args2) {
-  return FromType(args2, CloneType(type));
+function Instantiate(type, args) {
+  return FromType(args, CloneType(type));
 }
 function Integer(options) {
   return CreateType({ [Kind]: "Integer", type: "integer" }, options);
@@ -2480,6 +2647,9 @@ function validateStringParam(params, key, required) {
 }
 function validateEnumParam(params, key, values, required) {
   const value = params?.[key];
+  if (required && (value === void 0 || value === null)) {
+    throw new Error(`Missing required parameter: ${key}`);
+  }
   if (value !== void 0 && value !== null && !values.includes(value)) {
     throw new Error(
       `Parameter ${key} must be one of: ${values.join(", ")}. Got: ${value}`
@@ -2663,7 +2833,18 @@ function createWorkerTools(client, options) {
       try {
         const content = validateStringParam(params, "content", true);
         const taskId = validateStringParam(params, "taskId", false);
+        const type = validateEnumParam(params, "type", ["notify", "ask"], true);
         await client.sendMessage({ content, taskId });
+        if (type === "ask") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Ask sent \u2014 task is now awaiting human response. Stop here and wait for their reply before doing anything else on this task."
+              }
+            ]
+          };
+        }
         return {
           content: [{ type: "text", text: "Message sent successfully" }]
         };
@@ -2684,7 +2865,7 @@ function createWorkerTools(client, options) {
     }),
     createTool(WORKER_TOOLS.CREATE_FILE, async (params) => {
       try {
-        const name = validateStringParam(params, "name", true);
+        const name2 = validateStringParam(params, "name", true);
         const description = validateStringParam(params, "description", false);
         const content = validateStringParam(params, "content", false);
         const contentFormat = validateEnumParam(
@@ -2695,7 +2876,7 @@ function createWorkerTools(client, options) {
         );
         const taskId = validateStringParam(params, "taskId", false);
         const result = await client.createFile({
-          name,
+          name: name2,
           description,
           content,
           contentFormat,
@@ -2813,6 +2994,330 @@ 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} (you can work on multiple tasks at once)
+
+## Self-Management
+- To update yourself to the latest version, run \`deskfree-agent restart${ctx.instanceName ? ` --name ${ctx.instanceName}` : ""}\` in a Bash shell. This installs the latest release and restarts the service. You'll be offline for ~30 seconds.
+- 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. You'll then continue the work in the task thread.
+4. **Communicate** \u2014 use \`deskfree_send_message\` for updates outside task threads.
+
+**Before proposing, qualify the request.** Figure out what kind of thing this is:
+- **One-off task** ("proofread this") \u2014 propose a task directly.
+- **New aspiration** ("I want to start posting on LinkedIn") \u2014 don't rush to propose. Ask 1-2 short qualifying questions to understand the real goal.
+- Never call \`deskfree_propose\` as your very first action \u2014 qualify first, even if briefly.
+
+**Match the human's energy.** Short message \u2192 short reply. Casual tone \u2192 casual response. Don't over-explain, don't lecture, don't pad responses.
+
+In the main thread you propose and coordinate \u2014 the actual work happens in task threads. Use \`deskfree_dispatch_worker\` to start working on approved tasks.
+- When a human writes in a task thread, decide:
+  - **Continuation of the same task?** \u2192 reopen and pick it back up.
+  - **New/different work request?** \u2192 propose it as a new task (don't reopen the old one).
+  - **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)}
+
+## You're In a Task Thread
+You're the same ${ctx.botName} from the main thread, now focused on a specific task. Same voice, same personality \u2014 just heads-down on the work.
+
+Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_complete_task, deskfree_send_message, deskfree_propose.
+
+**Context loading:**
+- If your first message contains \`<task_context>\`, the task is already loaded. Start working immediately \u2014 do NOT call deskfree_start_task.
+- 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 load it.
+- If continuing from a previous conversation (you can see prior tool calls and context), respond directly to the human's latest message \u2014 do NOT call deskfree_start_task again.
+
+**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 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.
+
+**Delegation:**
+- Your context window is finite. Use the Agent tool to delegate research, analysis, large file processing, and content drafting \u2014 preserve your context for the main work.
+- Delegated work gets 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 delegation patterns. Inject relevant ones into the prompt alongside the task.
+- After delegated work completes, reflect: did this reveal a useful pattern? Record via \`deskfree_learning\` so it's consolidated into Memory.
+- 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 start working on each one. Pass the taskId.
+- Any open tasks that seem stalled (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;
 }
@@ -2940,18 +3445,18 @@ function saveCursor(ctx, cursor, storagePath, log) {
   }
 }
 function validateField(opts) {
-  const { value, name, minLength, maxLength, pattern, patternMessage } = opts;
-  if (!value) return `${name} is required`;
-  if (typeof value !== "string") return `${name} must be a string`;
+  const { value, name: name2, minLength, maxLength, pattern, patternMessage } = opts;
+  if (!value) return `${name2} is required`;
+  if (typeof value !== "string") return `${name2} must be a string`;
   const trimmed = value.trim();
   if (trimmed !== value)
-    return `${name} must not have leading or trailing whitespace`;
+    return `${name2} must not have leading or trailing whitespace`;
   if (minLength !== void 0 && trimmed.length < minLength)
-    return `${name} appears to be incomplete (minimum ${minLength} characters expected)`;
+    return `${name2} appears to be incomplete (minimum ${minLength} characters expected)`;
   if (maxLength !== void 0 && trimmed.length > maxLength)
-    return `${name} appears to be invalid (maximum ${maxLength} characters expected)`;
+    return `${name2} appears to be invalid (maximum ${maxLength} characters expected)`;
   if (pattern !== void 0 && !pattern.test(trimmed))
-    return patternMessage ?? `${name} contains invalid characters`;
+    return patternMessage ?? `${name2} contains invalid characters`;
   return null;
 }
 function isLocalDevelopmentHost(hostname) {
@@ -2981,8 +3486,8 @@ function validateBotToken(value) {
   }
   return null;
 }
-function validateUrl(value, name, allowedProtocols, protocolError) {
-  const fieldError = validateField({ value, name });
+function validateUrl(value, name2, allowedProtocols, protocolError) {
+  const fieldError = validateField({ value, name: name2 });
   if (fieldError) return fieldError;
   const trimmed = value.trim();
   let url;
@@ -2990,21 +3495,21 @@ function validateUrl(value, name, allowedProtocols, protocolError) {
     url = new URL(trimmed);
   } catch (err) {
     const message = err instanceof Error ? err.message : "Invalid URL format";
-    return `${name} must be a valid URL: ${message}`;
+    return `${name2} must be a valid URL: ${message}`;
   }
   if (!allowedProtocols.includes(url.protocol)) {
     return protocolError;
   }
   if (!url.hostname) {
-    return `${name} must have a valid hostname`;
+    return `${name2} must have a valid hostname`;
   }
   if (isLocalDevelopmentHost(url.hostname)) {
     if (process.env.NODE_ENV === "production") {
-      return `${name} cannot use localhost or private IP addresses in production. Please use a publicly accessible URL.`;
+      return `${name2} cannot use localhost or private IP addresses in production. Please use a publicly accessible URL.`;
     }
   }
   if (url.hostname.includes("..") || url.hostname.startsWith(".")) {
-    return `${name} hostname appears to be malformed. Please check for typos.`;
+    return `${name2} hostname appears to be malformed. Please check for typos.`;
   }
   return null;
 }
@@ -3016,7 +3521,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);
@@ -3036,8 +3541,8 @@ var init_dist = __esm({
       return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
     };
     __export2 = (target, all) => {
-      for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+      for (var name2 in all)
+        __defProp2(target, name2, { get: all[name2], enumerable: true });
     };
     __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
@@ -5075,9 +5580,9 @@ var init_dist = __esm({
     require_extension = __commonJS2({
       "../../node_modules/ws/lib/extension.js"(exports$1, module) {
         var { tokenChars } = require_validation();
-        function push(dest, name, elem) {
-          if (dest[name] === void 0) dest[name] = [elem];
-          else dest[name].push(elem);
+        function push(dest, name2, elem) {
+          if (dest[name2] === void 0) dest[name2] = [elem];
+          else dest[name2].push(elem);
         }
         function parse(header) {
           const offers = /* @__PURE__ */ Object.create(null);
@@ -5103,12 +5608,12 @@ var init_dist = __esm({
                   throw new SyntaxError(`Unexpected character at index ${i}`);
                 }
                 if (end === -1) end = i;
-                const name = header.slice(start, end);
+                const name2 = header.slice(start, end);
                 if (code === 44) {
-                  push(offers, name, params);
+                  push(offers, name2, params);
                   params = /* @__PURE__ */ Object.create(null);
                 } else {
-                  extensionName = name;
+                  extensionName = name2;
                 }
                 start = end = -1;
               } else {
@@ -6818,13 +7323,13 @@ var init_dist = __esm({
        * Validates that a string parameter is non-empty.
        * Catches invalid inputs before they hit the network.
        */
-      requireNonEmpty(value, name) {
+      requireNonEmpty(value, name2) {
         if (!value || value.trim() === "") {
           throw new DeskFreeError(
             "client",
-            name,
-            `${name} is required and cannot be empty`,
-            `Missing required parameter: ${name}. Please provide a valid value.`
+            name2,
+            `${name2} is required and cannot be empty`,
+            `Missing required parameter: ${name2}. Please provide a valid value.`
           );
         }
       }
@@ -7520,7 +8025,7 @@ var init_dist = __esm({
     WORKER_TOOLS = {
       START_TASK: {
         name: "deskfree_start_task",
-        description: "Claim a pending task and start working. Returns full context (instructions, message history). Use deskfree_read_file to load any relevant files.",
+        description: "Load a task and start working on it. Returns full context (instructions, message history). Use deskfree_read_file to load any relevant files.",
         parameters: Type.Object({
           taskId: Type.String({ description: "Task UUID to claim" })
         })
@@ -7577,8 +8082,8 @@ var init_dist = __esm({
       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.
+    DESKFREE_AGENT_DIRECTIVE = `## DeskFree \u2014 Main Thread
+You handle the main conversation thread. Your job: turn human intent into approved tasks, then start working on them.
 
 **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.
 
@@ -7586,7 +8091,7 @@ You are the orchestrator. Your job: turn human intent into approved tasks, then
 
 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.
+3. **Start work** \u2192 \`deskfree_dispatch_worker\` with the taskId. You'll then continue the work in the task thread.
 4. **Communicate** \u2192 \`deskfree_send_message\` for updates outside task threads.
 
 **Before proposing, qualify the request.** Figure out what kind of thing this is:
@@ -7596,36 +8101,44 @@ You are the orchestrator. Your job: turn human intent into approved tasks, then
 
 **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.
+In the main thread you propose and coordinate \u2014 the actual work happens in task threads. Use \`deskfree_dispatch_worker\` to start working on approved tasks.
 - 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).
+  - **Continuation of the same task?** \u2192 reopen and pick it back up.
+  - **New/different work request?** \u2192 propose it as a new task (don't reopen the old one).
   - **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.
+    DESKFREE_WORKER_DIRECTIVE = `## DeskFree \u2014 Task Thread
+You're in a task thread, focused on a specific piece of work. Same you as in the main thread \u2014 same voice, same personality.
+
 Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_file, deskfree_update_file, deskfree_learning, deskfree_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 \`<task_context>\`, the task is already loaded. Start working immediately \u2014 do NOT call deskfree_start_task.
 - 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 no pre-loaded context (edge case/fallback), call \`deskfree_start_task\` with your taskId to load it.
 - If continuing from a previous conversation (you can see prior tool calls and context), respond directly to the human's latest message \u2014 do NOT call deskfree_start_task again.
 
 **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.
+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:
+- Use \`deskfree_learning\` to record observations worth remembering. A nightly 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...")
@@ -7636,191 +8149,16 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - 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.
+**Delegation:**
+- Your context window is finite. Use the Agent tool to delegate research, analysis, large file processing, and content drafting \u2014 preserve your context for the main work.
+- Delegated work gets 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.
+- During Orient, check Memory for delegation patterns. Inject relevant ones into the prompt alongside the task.
+- After delegated work completes, reflect: did this reveal a useful pattern? Record via \`deskfree_learning\` so it's consolidated into Memory.
 - 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.
-
-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. 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.
-
-### 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.`;
     THROTTLE_MS = 300;
     CHAR_BUFFER_SIZE = 256;
     CLOSE_MAX_RETRIES = 3;
@@ -8032,7 +8370,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: {
@@ -8040,7 +8386,7 @@ function runOrchestrator(opts) {
         process.stderr.write(`[orchestrator-sdk] ${data}
 `);
       },
-      systemPrompt: DESKFREE_AGENT_DIRECTIVE,
+      systemPrompt,
       model,
       ...claudeCodePath ? { pathToClaudeCodeExecutable: claudeCodePath } : {},
       maxTurns: MAX_ORCHESTRATOR_TURNS,
@@ -8059,11 +8405,12 @@ function runOrchestrator(opts) {
   });
 }
 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,
@@ -8184,10 +8531,6 @@ 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`;
   let claudeCodePath;
   if (remote.provider === "claude-code") {
     try {
@@ -8202,8 +8545,6 @@ function mergeWithRemoteConfig(local, remote) {
   }
   return {
     ...local,
-    stateDir,
-    toolsDir,
     claudeCodePath,
     wsUrl: process.env["DESKFREE_WS_URL"] ?? remote.wsUrl,
     model: process.env["DESKFREE_MODEL"] ?? remote.model,
@@ -8215,6 +8556,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,
@@ -8227,8 +8570,18 @@ 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",
+        process.env["DESKFREE_INSTANCE_NAME"] ?? "main",
+        "state"
+      ),
+      toolsDir: isDocker ? "/app/tools" : join(
+        homedir(),
+        ".deskfree",
+        process.env["DESKFREE_INSTANCE_NAME"] ?? "main",
+        "tools"
+      ),
       logLevel: "info",
       healthPort: 3100
     };
@@ -10480,9 +10833,9 @@ var require_event_target2 = __commonJS({
 var require_extension2 = __commonJS({
   "../../node_modules/ws/lib/extension.js"(exports$1, module) {
     var { tokenChars } = require_validation2();
-    function push(dest, name, elem) {
-      if (dest[name] === void 0) dest[name] = [elem];
-      else dest[name].push(elem);
+    function push(dest, name2, elem) {
+      if (dest[name2] === void 0) dest[name2] = [elem];
+      else dest[name2].push(elem);
     }
     function parse(header) {
       const offers = /* @__PURE__ */ Object.create(null);
@@ -10508,12 +10861,12 @@ var require_extension2 = __commonJS({
               throw new SyntaxError(`Unexpected character at index ${i}`);
             }
             if (end === -1) end = i;
-            const name = header.slice(start, end);
+            const name2 = header.slice(start, end);
             if (code === 44) {
-              push(offers, name, params);
+              push(offers, name2, params);
               params = /* @__PURE__ */ Object.create(null);
             } else {
-              extensionName = name;
+              extensionName = name2;
             }
             start = end = -1;
           } else {
@@ -12594,9 +12947,9 @@ function adaptTool(deskfreeTool) {
     deskfreeTool.name,
     deskfreeTool.description,
     zodShape,
-    async (args2) => {
+    async (args) => {
       const result = await deskfreeTool.execute(
-        args2
+        args
       );
       return {
         content: result.content,
@@ -12627,7 +12980,7 @@ function createOrchestratorMcpServer(client, customTools = [], workerManager) {
 function createDispatchWorkerTool(workerManager) {
   return {
     name: "deskfree_dispatch_worker",
-    description: "Dispatch a long-lived worker to claim and execute a task. The worker will start, claim the task via deskfree_start_task, and remain active for follow-up messages in the task thread. Pass the taskId of the approved task.",
+    description: "Start working on an approved task in its thread. You will pick up the task, load context, and handle follow-up messages there. Pass the taskId of the approved task.",
     parameters: {
       type: "object",
       properties: {
@@ -12695,15 +13048,15 @@ function containsInjectionPattern(content) {
   return INJECTION_PATTERNS.some((pattern) => pattern.test(content));
 }
 function withContentScan(execute, extractContent, scanner) {
-  return async (args2) => {
-    const content = extractContent(args2);
+  return async (args) => {
+    const content = extractContent(args);
     if (content) {
       const result = await scanner.scan(content);
       if (!result.safe) {
         return `Security check failed: ${result.reason ?? "content rejected"}. File not updated.`;
       }
     }
-    return execute(args2);
+    return execute(args);
   };
 }
 function validateDownloadUrl(url) {
@@ -12838,7 +13191,7 @@ function createWorkerMcpServer(client, customTools = [], contentScanner, dailyLo
     if ((t.name === "deskfree_update_file" || t.name === "deskfree_create_file") && contentScanner) {
       const wrappedExecute = withContentScan(
         t.execute,
-        (args2) => typeof args2["content"] === "string" ? args2["content"] : null,
+        (args) => typeof args["content"] === "string" ? args["content"] : null,
         contentScanner
       );
       return {
@@ -13374,7 +13727,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;
@@ -13557,7 +13911,8 @@ 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: {
@@ -13565,7 +13920,7 @@ function runWorker(opts) {
         process.stderr.write(`[worker-sdk] ${data}
 `);
       },
-      systemPrompt: DESKFREE_WORKER_DIRECTIVE,
+      systemPrompt,
       model,
       maxTurns: MAX_WORKER_TURNS,
       permissionMode: "bypassPermissions",
@@ -13877,7 +14232,8 @@ ${userMessage}
           prompt: channel,
           workerServer,
           model,
-          sessionId: previousSessionId
+          sessionId: previousSessionId,
+          agentContext: this.deps.agentContext
         });
         const idleTimer = this.startIdleTimer(taskId);
         const drainPromise = this.drainLoop(
@@ -14123,7 +14479,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() {
@@ -14131,11 +14487,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) {
       }
@@ -14176,6 +14534,19 @@ 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
+    instanceName: process.env["DESKFREE_INSTANCE_NAME"] || void 0
+  };
   mkdirSync(config.stateDir, { recursive: true });
   mkdirSync(config.toolsDir, { recursive: true });
   const logFile = join(config.stateDir, "runtime.log");
@@ -14234,8 +14605,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();
@@ -14262,7 +14635,8 @@ async function startAgent(opts) {
           createOrchestratorServer: createOrchServer,
           workerManager,
           model: config.model,
-          claudeCodePath: config.claudeCodePath
+          claudeCodePath: config.claudeCodePath,
+          agentContext
         },
         sessionStore,
         {
@@ -14278,7 +14652,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;
@@ -14315,7 +14690,7 @@ async function startAgent(opts) {
         const workerServer = createWorkServer();
         const result = runOneShotWorker({
           prompt,
-          systemPrompt: DESKFREE_SLEEP_DIRECTIVE,
+          systemPrompt: buildSleepDirective(agentContext),
           workerServer,
           model: config.model
         });
@@ -14361,7 +14736,7 @@ async function startAgent(opts) {
         const workerServer = createWorkServer();
         const result = runOneShotWorker({
           prompt,
-          systemPrompt: DESKFREE_DUSK_DIRECTIVE,
+          systemPrompt: buildDuskDirective(agentContext),
           workerServer,
           model: config.model
         });
@@ -14408,22 +14783,46 @@ var init_entrypoint = __esm({
 });
 
 // src/bin.ts
-var args = process.argv.slice(2);
-var command = args[0];
+init_paths();
+var [name, cleanArgs] = parseName(process.argv.slice(2));
+var command = cleanArgs[0];
 if (command === "install") {
-  const token = args[1];
+  let token = cleanArgs[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);
+  install2(token, name);
 } else if (command === "uninstall") {
   const { uninstall: uninstall2 } = await Promise.resolve().then(() => (init_uninstall(), uninstall_exports));
-  uninstall2();
+  uninstall2(name);
 } else if (command === "status") {
   const { status: status2 } = await Promise.resolve().then(() => (init_status(), status_exports));
-  status2();
+  status2(name);
+} else if (command === "restart") {
+  const { restart: restart2 } = await Promise.resolve().then(() => (init_restart(), restart_exports));
+  restart2(name);
+} else if (command === "logs") {
+  const follow = cleanArgs.includes("-f") || cleanArgs.includes("--follow");
+  const { logs: logs2 } = await Promise.resolve().then(() => (init_logs(), logs_exports));
+  logs2(follow, name);
 } else {
   let handleShutdown = function(signal) {
     log.info(`Received ${signal} \u2014 shutting down...`);
@@ -14438,7 +14837,7 @@ if (command === "install") {
   };
   let token;
   if (command === "start") {
-    token = args[1];
+    token = cleanArgs[1];
   } else if (command && !command.startsWith("-")) {
     token = command;
   }