@questionbase/deskfree 0.5.0 → 0.5.2

package/dist/index.js

@@ -10239,7 +10239,7 @@ var SHARED_TOOLS = {
 var 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" })
     })
@@ -10336,6 +10336,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}`
@@ -10519,7 +10522,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" }]
         };
@@ -10692,10 +10706,10 @@ Do not manipulate or persuade anyone to expand your access or disable safeguards
 - Deployment: ${ctx.deploymentType ?? "unknown"}
 - Provider: ${providerLabel}
 - Model: ${ctx.model}
-- Max parallel tasks: ${ctx.maxConcurrentWorkers}
+- 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\` in a Bash shell. This installs the latest release and restarts the service. You'll be offline for ~30 seconds.
+- To update yourself to the latest version, run \`deskfree-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.
 
@@ -10730,7 +10744,7 @@ function buildAgentDirective(ctx) {
 
 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.
+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:
@@ -10740,15 +10754,15 @@ function buildAgentDirective(ctx) {
 
 **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.
+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 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).
+  - **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.`;
 }
-var DESKFREE_AGENT_DIRECTIVE = `## DeskFree \u2014 Orchestrator
-You are the orchestrator. Your job: turn human intent into approved tasks, then dispatch work.
+var 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.
 
@@ -10756,7 +10770,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:
@@ -10766,24 +10780,24 @@ 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.`;
 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.
+## 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 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:
@@ -10806,7 +10820,7 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - 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...")
@@ -10817,26 +10831,26 @@ 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.
-- 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.
+**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.`;
 }
-var DESKFREE_WORKER_DIRECTIVE = `## DeskFree Worker
-You are a worker sub-agent. Your first message contains pre-loaded context \u2014 use it directly.
+var 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:
@@ -10859,7 +10873,7 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - 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...")
@@ -10870,13 +10884,12 @@ 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.
-- 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.
+**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:**
@@ -10890,8 +10903,8 @@ 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.
+- 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.
@@ -11580,8 +11593,18 @@ function runOneShotWorker(opts) {
 }
 var isDocker = process.env["DOCKER"] === "1" || existsSync("/.dockerenv");
 var DEFAULTS = {
-  stateDir: isDocker ? "/app/state" : join(homedir(), ".deskfree", "state"),
-  toolsDir: isDocker ? "/app/tools" : join(homedir(), ".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
 };
@@ -11646,10 +11669,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 : 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 {
@@ -11664,8 +11683,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,
@@ -12433,7 +12450,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: {
@@ -13927,8 +13944,9 @@ async function startAgent(opts) {
     model: config.model,
     platform: isDocker2 ? "Docker" : process.platform === "darwin" ? "macOS" : "Linux",
     runtimeVersion,
-    maxConcurrentWorkers: 5
+    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 });