@questionbase/deskfree 0.5.3 → 0.6.1

package/dist/bin.js

@@ -56,7 +56,7 @@ function getPlistLabel(name2) {
   return `com.deskfree.agent.${name2}`;
 }
 function getServiceName(name2) {
-  return `deskfree-agent-${name2}`;
+  return `deskfree-${name2}`;
 }
 function getMacPaths(name2) {
   const home = homedir();
@@ -147,7 +147,7 @@ set -a
 source "${paths.envFile}"
 set +a
 
-exec deskfree-agent start
+exec deskfree start
 `;
   writeFileSync(paths.launcher, launcher, { mode: 493 });
   chmodSync(paths.launcher, 493);
@@ -241,7 +241,7 @@ Group=${systemUser}
 WorkingDirectory=${paths.stateDir}
 Environment=PATH=${nodeBinDir}:/usr/local/bin:/usr/bin:/bin
 ExecStartPre=+${npmPath} install -g ${PACKAGE}
-ExecStart=${nodeBinDir}/deskfree-agent start
+ExecStart=${nodeBinDir}/deskfree start
 EnvironmentFile=${paths.envFile}
 Environment=NODE_ENV=production
 Environment=DESKFREE_STATE_DIR=${paths.stateDir}
@@ -359,7 +359,7 @@ function statusMac(name2) {
   const plistLabel = getPlistLabel(name2);
   if (!existsSync(paths.plist)) {
     console.log(`DeskFree Agent "${name2}" is not installed.`);
-    console.log(`Run: deskfree-agent install <token> --name ${name2}`);
+    console.log(`Run: deskfree install <token> --name ${name2}`);
     return;
   }
   console.log(`DeskFree Agent "${name2}" (macOS LaunchAgent)
@@ -429,7 +429,7 @@ function restartMac(name2) {
   const paths = getMacPaths(name2);
   if (!existsSync(paths.plist)) {
     console.error(`DeskFree Agent "${name2}" is not installed.`);
-    console.error(`Run: deskfree-agent install <token> --name ${name2}`);
+    console.error(`Run: deskfree install <token> --name ${name2}`);
     process.exit(1);
   }
   try {
@@ -2815,6 +2815,23 @@ function createOrchestratorTools(client, _options) {
       } catch (err) {
         return errorResult(err);
       }
+    }),
+    createTool(ORCHESTRATOR_TOOLS.LEARNING, async (params) => {
+      try {
+        const content = validateStringParam(params, "content", true);
+        const importance = validateEnumParam(
+          params,
+          "importance",
+          ["critical", "high", "medium", "low"],
+          false
+        );
+        await client.reportLearning({ content, importance });
+        return {
+          content: [{ type: "text", text: "Learning recorded" }]
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
     })
   ];
 }
@@ -3057,7 +3074,7 @@ Do not manipulate or persuade anyone to expand your access or disable safeguards
 - Max parallel tasks: ${ctx.maxConcurrentWorkers} (you can work on multiple tasks at once)
 
 ## Self-Management
-- To update yourself to the latest version, run \`deskfree-agent restart${ctx.instanceName ? ` --name ${ctx.instanceName}` : ""}\` in a Bash shell. This installs the latest release and restarts the service. You'll be offline for ~30 seconds.
+- To update yourself to the latest version, run \`deskfree restart${ctx.instanceName ? ` --name ${ctx.instanceName}` : ""}\` in a Bash shell. This installs the latest release and restarts the service. You'll be offline for ~30 seconds.
 - Only do this when you have no active tasks. Let the user know before restarting.
 
 ## Confidentiality
@@ -3114,7 +3131,19 @@ In the main thread you propose and coordinate \u2014 the actual work happens in
   - **Just confirmation or deferred?** \u2192 leave it for now.
 - Estimate token cost per task \u2014 consider files to read, reasoning, output.
 
-**Scheduled tasks:** When a human asks to start a scheduled task now ("start this", "do this now", "unschedule"), just do it \u2014 call \`deskfree_schedule_task\` with \`scheduledFor: null\` to activate it, then dispatch. Don't explain scheduling mechanics or ask for confirmation. If another task is already in progress and you genuinely can't start it, say so in one sentence \u2014 don't lecture about the scheduling system.`;
+**Scheduled tasks:** When a human asks to start a scheduled task now ("start this", "do this now", "unschedule"), just do it \u2014 call \`deskfree_schedule_task\` with \`scheduledFor: null\` to activate it, then dispatch. Don't explain scheduling mechanics or ask for confirmation. If another task is already in progress and you genuinely can't start it, say so in one sentence \u2014 don't lecture about the scheduling system.
+
+**Learnings \u2014 record aggressively:**
+Use \`deskfree_learning\` to record anything worth remembering. **Err on the side of recording too much** \u2014 the nightly sleep cycle will consolidate and prune. You lose nothing by over-recording, but you lose knowledge by under-recording.
+
+Record across all five types:
+- **Corrections**: "Do X, not Y" \u2014 when the human corrects your approach (\`importance: critical\`)
+- **Preferences**: How they want things done \u2014 tone, format, workflow, style (\`importance: high\`)
+- **Patterns**: Approaches that consistently work or fail (\`importance: medium\`)
+- **Domain facts**: Business context, project-specific knowledge, key relationships (\`importance: medium\`)
+- **Insights**: Non-obvious connections, meta-observations about the work (\`importance: low\`)
+
+Record immediately when: the human corrects you, expresses a preference, shares context about their business, reacts strongly to something (positive or negative), or you discover something that would help future tasks.`;
 }
 function buildWorkerDirective(ctx) {
   return `${identityBlock(ctx)}
@@ -3152,15 +3181,19 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - Always pass \`taskId\` when creating or updating files \u2014 this threads notifications into the task.
 - If you discover work that falls outside your task's scope, use \`deskfree_propose\` to suggest follow-up tasks immediately \u2014 don't wait until completion. Propose as you discover, then stay focused on your current task.
 
-**Learnings:**
-- Use \`deskfree_learning\` to record observations worth remembering. Set the \`importance\` parameter:
-  - **critical**: corrections, constraints that must never be violated
-  - **high**: strong preferences, important patterns
-  - **medium**: useful context, moderate preferences
-  - **low** (default): routine observations
-- Record: preferences, corrections, patterns, domain facts.
-- Do NOT record one-time task details, things in project docs, or obvious/generic knowledge.
-- A nightly sleep cycle consolidates observations into long-term memory with decay scoring.
+**Learnings \u2014 record aggressively:**
+Use \`deskfree_learning\` to record anything worth remembering. **Err on the side of recording too much** \u2014 the nightly sleep cycle will consolidate and prune. You lose nothing by over-recording, but you lose knowledge by under-recording.
+
+Record across all five types:
+- **Corrections**: "Do X, not Y" \u2014 when the human corrects your approach (\`importance: critical\`)
+- **Preferences**: How they want things done \u2014 tone, format, workflow, style (\`importance: high\`)
+- **Patterns**: Approaches that consistently work or fail (\`importance: medium\`)
+- **Domain facts**: Business context, project-specific knowledge, key relationships (\`importance: medium\`)
+- **Insights**: Non-obvious connections, meta-observations about the work (\`importance: low\`)
+
+Record immediately when: the human corrects you, expresses a preference, shares context about their business, reacts strongly to something, or you discover something that would help future tasks.
+
+Do NOT record: one-time task details, things already in project docs, or obvious/generic knowledge.
 
 **Memory recall:**
 - Use \`deskfree_orient\` to recall relevant memories mid-task. Call with a specific query for targeted semantic search.
@@ -7994,6 +8027,28 @@ var init_dist = __esm({
             })
           )
         })
+      },
+      LEARNING: {
+        name: "deskfree_learning",
+        description: "Record a learning \u2014 an observation worth remembering for future tasks. Embedded and stored in long-term memory, consolidated nightly. Call as many times as needed. Err on the side of recording too much.",
+        parameters: Type.Object({
+          content: Type.String({
+            description: 'What you learned. Focus on: CORRECTIONS, PREFERENCES, PATTERNS, DOMAIN FACTS, INSIGHTS. Be specific. Bad: "User wants a blog post". Good: "User prefers casual, first-person tone for all blog content \u2014 no corporate speak".'
+          }),
+          importance: Type.Optional(
+            Type.Union(
+              [
+                Type.Literal("critical"),
+                Type.Literal("high"),
+                Type.Literal("medium"),
+                Type.Literal("low")
+              ],
+              {
+                description: "Importance level. critical = corrections/constraints that must never be violated. high = strong preferences/patterns. medium = useful context. low = routine observations. Defaults to low."
+              }
+            )
+          )
+        })
       }
     };
     SHARED_TOOLS = {
@@ -8149,10 +8204,10 @@ var init_dist = __esm({
       UPDATE_FILE: SHARED_TOOLS.UPDATE_FILE,
       LEARNING: {
         name: "deskfree_learning",
-        description: "Record a learning \u2014 an observation worth remembering for future tasks. Embedded and stored in long-term memory, consolidated nightly. Call as many times as needed.",
+        description: "Record a learning \u2014 an observation worth remembering for future tasks. Embedded and stored in long-term memory, consolidated nightly. Call as many times as needed. Err on the side of recording too much.",
         parameters: Type.Object({
           content: Type.String({
-            description: 'What you learned. Focus on: PREFERENCES, CORRECTIONS, PATTERNS, DOMAIN FACTS. Be specific. Bad: "Created a table". Good: "User corrected: never use semicolons in this codebase".'
+            description: 'What you learned. Focus on: CORRECTIONS, PREFERENCES, PATTERNS, DOMAIN FACTS, INSIGHTS. Be specific. Bad: "Created a table". Good: "User corrected: never use semicolons in this codebase".'
           }),
           importance: Type.Optional(
             Type.Union(
@@ -8205,7 +8260,19 @@ In the main thread you propose and coordinate \u2014 the actual work happens in
   - **Just confirmation or deferred?** \u2192 leave it for now.
 - Estimate token cost per task \u2014 consider files to read, reasoning, output.
 
-**Scheduled tasks:** When a human asks to start a scheduled task now ("start this", "do this now", "unschedule"), just do it \u2014 call \`deskfree_schedule_task\` with \`scheduledFor: null\` to activate it, then dispatch. Don't explain scheduling mechanics or ask for confirmation. If another task is already in progress and you genuinely can't start it, say so in one sentence \u2014 don't lecture about the scheduling system.`;
+**Scheduled tasks:** When a human asks to start a scheduled task now ("start this", "do this now", "unschedule"), just do it \u2014 call \`deskfree_schedule_task\` with \`scheduledFor: null\` to activate it, then dispatch. Don't explain scheduling mechanics or ask for confirmation. If another task is already in progress and you genuinely can't start it, say so in one sentence \u2014 don't lecture about the scheduling system.
+
+**Learnings \u2014 record aggressively:**
+Use \`deskfree_learning\` to record anything worth remembering. **Err on the side of recording too much** \u2014 the nightly sleep cycle will consolidate and prune. You lose nothing by over-recording, but you lose knowledge by under-recording.
+
+Record across all five types:
+- **Corrections**: "Do X, not Y" \u2014 when the human corrects your approach (\`importance: critical\`)
+- **Preferences**: How they want things done \u2014 tone, format, workflow, style (\`importance: high\`)
+- **Patterns**: Approaches that consistently work or fail (\`importance: medium\`)
+- **Domain facts**: Business context, project-specific knowledge, key relationships (\`importance: medium\`)
+- **Insights**: Non-obvious connections, meta-observations about the work (\`importance: low\`)
+
+Record immediately when: the human corrects you, expresses a preference, shares context about their business, reacts strongly to something (positive or negative), or you discover something that would help future tasks.`;
     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.
 
@@ -8239,15 +8306,19 @@ Tools: deskfree_state, deskfree_start_task, deskfree_read_file, deskfree_create_
 - Always pass \`taskId\` when creating or updating files \u2014 this threads notifications into the task.
 - If you discover work that falls outside your task's scope, use \`deskfree_propose\` to suggest follow-up tasks immediately \u2014 don't wait until completion. Propose as you discover, then stay focused on your current task.
 
-**Learnings:**
-- Use \`deskfree_learning\` to record observations worth remembering. Set the \`importance\` parameter:
-  - **critical**: corrections, constraints that must never be violated
-  - **high**: strong preferences, important patterns
-  - **medium**: useful context, moderate preferences
-  - **low** (default): routine observations
-- Record: preferences, corrections, patterns, domain facts.
-- Do NOT record one-time task details, things in project docs, or obvious/generic knowledge.
-- A nightly sleep cycle consolidates observations into long-term memory with decay scoring.
+**Learnings \u2014 record aggressively:**
+Use \`deskfree_learning\` to record anything worth remembering. **Err on the side of recording too much** \u2014 the nightly sleep cycle will consolidate and prune. You lose nothing by over-recording, but you lose knowledge by under-recording.
+
+Record across all five types:
+- **Corrections**: "Do X, not Y" \u2014 when the human corrects your approach (\`importance: critical\`)
+- **Preferences**: How they want things done \u2014 tone, format, workflow, style (\`importance: high\`)
+- **Patterns**: Approaches that consistently work or fail (\`importance: medium\`)
+- **Domain facts**: Business context, project-specific knowledge, key relationships (\`importance: medium\`)
+- **Insights**: Non-obvious connections, meta-observations about the work (\`importance: low\`)
+
+Record immediately when: the human corrects you, expresses a preference, shares context about their business, reacts strongly to something, or you discover something that would help future tasks.
+
+Do NOT record: one-time task details, things already in project docs, or obvious/generic knowledge.
 
 **Memory recall:**
 - Use \`deskfree_orient\` to recall relevant memories mid-task. Call with a specific query for targeted semantic search.
@@ -12575,7 +12646,8 @@ async function startGateway(config) {
         log,
         abortSignal,
         onMessage: config.onMessage,
-        getWorkerStatus: config.getWorkerStatus
+        getWorkerStatus: config.getWorkerStatus,
+        onConsolidate: config.onConsolidate
       });
       totalReconnects++;
     } catch (err) {
@@ -12828,6 +12900,34 @@ async function runWebSocketConnection(opts) {
               })
             );
           }
+        } else if (msg.action === "consolidate") {
+          if (opts.onConsolidate && ws.readyState === wrapper_default2.OPEN) {
+            opts.onConsolidate().then(
+              (consolidateStatus) => {
+                if (ws.readyState === wrapper_default2.OPEN) {
+                  ws.send(
+                    JSON.stringify({
+                      action: "consolidateResponse",
+                      status: consolidateStatus
+                    })
+                  );
+                }
+              },
+              (consolidateErr) => {
+                const errMsg = consolidateErr instanceof Error ? consolidateErr.message : String(consolidateErr);
+                log.warn(`On-demand consolidation failed: ${errMsg}`);
+                if (ws.readyState === wrapper_default2.OPEN) {
+                  ws.send(
+                    JSON.stringify({
+                      action: "consolidateResponse",
+                      status: "error",
+                      error: errMsg
+                    })
+                  );
+                }
+              }
+            );
+          }
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -14762,7 +14862,8 @@ async function startAgent(opts) {
           log
         }
       );
-    }
+    },
+    onConsolidate: () => runConsolidation()
   });
   scheduleHeartbeat(
     createOrchServer,
@@ -14773,64 +14874,76 @@ async function startAgent(opts) {
     config.claudeCodePath,
     agentContext
   );
+  let isConsolidating = false;
+  async function runConsolidation() {
+    if (isConsolidating) {
+      log.info("Consolidation already in progress, skipping");
+      return "already_running";
+    }
+    isConsolidating = true;
+    try {
+      let orientResult;
+      try {
+        orientResult = await client.orient({ consolidation: true });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.warn(`Sleep cycle: orient() failed: ${msg}`);
+        return "error";
+      }
+      if (orientResult.entries.length === 0) {
+        log.info("Sleep cycle: no unconsolidated entries to process, skipping");
+        return "noop";
+      }
+      const unconsolidatedSection = orientResult.entries.map(
+        (e) => `- [${e.entryId}] ${e.importance ? `(${e.importance}) ` : ""}${e.content}`
+      ).join("\n");
+      const relatedSection = orientResult.recentEntries && orientResult.recentEntries.length > 0 ? orientResult.recentEntries.map(
+        (e) => `- [${e.entryId}] [${e.type ?? "unclassified"}] s:${e.strength} \u2014 ${e.content}`
+      ).join("\n") : "(none)";
+      const dedupSection = orientResult.dedupCandidates && orientResult.dedupCandidates.length > 0 ? orientResult.dedupCandidates.map(
+        (d) => `- ${d.entryId1} \u2194 ${d.entryId2} (similarity: ${d.similarity.toFixed(3)})`
+      ).join("\n") : "(none)";
+      const prompt = [
+        "<current_operating_memory>",
+        orientResult.operatingMemory || "(empty \u2014 first consolidation)",
+        "</current_operating_memory>",
+        "",
+        "<unconsolidated_entries>",
+        unconsolidatedSection,
+        "</unconsolidated_entries>",
+        "",
+        "<related_active_entries>",
+        relatedSection,
+        "</related_active_entries>",
+        "",
+        "<dedup_candidates>",
+        dedupSection,
+        "</dedup_candidates>",
+        "",
+        "Run your nightly consolidation cycle now."
+      ].join("\n");
+      log.info(
+        `Sleep cycle: invoking sleep agent (${orientResult.entries.length} unconsolidated entries)...`
+      );
+      const workerServer = createWorkServer();
+      const result = runOneShotWorker({
+        prompt,
+        systemPrompt: buildSleepDirective(agentContext),
+        workerServer,
+        model: config.model
+      });
+      for await (const _ of result) {
+      }
+      return "success";
+    } finally {
+      isConsolidating = false;
+    }
+  }
   if (config.sleepHour !== null && config.timezone) {
     scheduleDailyCycle(
       "Sleep",
       async () => {
-        let orientResult;
-        try {
-          orientResult = await client.orient({ consolidation: true });
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          log.warn(`Sleep cycle: orient() failed: ${msg}`);
-          return;
-        }
-        if (orientResult.entries.length === 0) {
-          log.info(
-            "Sleep cycle: no unconsolidated entries to process, skipping"
-          );
-          return;
-        }
-        const unconsolidatedSection = orientResult.entries.map(
-          (e) => `- [${e.entryId}] ${e.importance ? `(${e.importance}) ` : ""}${e.content}`
-        ).join("\n");
-        const relatedSection = orientResult.recentEntries && orientResult.recentEntries.length > 0 ? orientResult.recentEntries.map(
-          (e) => `- [${e.entryId}] [${e.type ?? "unclassified"}] s:${e.strength} \u2014 ${e.content}`
-        ).join("\n") : "(none)";
-        const dedupSection = orientResult.dedupCandidates && orientResult.dedupCandidates.length > 0 ? orientResult.dedupCandidates.map(
-          (d) => `- ${d.entryId1} \u2194 ${d.entryId2} (similarity: ${d.similarity.toFixed(3)})`
-        ).join("\n") : "(none)";
-        const prompt = [
-          "<current_operating_memory>",
-          orientResult.operatingMemory || "(empty \u2014 first consolidation)",
-          "</current_operating_memory>",
-          "",
-          "<unconsolidated_entries>",
-          unconsolidatedSection,
-          "</unconsolidated_entries>",
-          "",
-          "<related_active_entries>",
-          relatedSection,
-          "</related_active_entries>",
-          "",
-          "<dedup_candidates>",
-          dedupSection,
-          "</dedup_candidates>",
-          "",
-          "Run your nightly consolidation cycle now."
-        ].join("\n");
-        log.info(
-          `Sleep cycle: invoking sleep agent (${orientResult.entries.length} unconsolidated entries)...`
-        );
-        const workerServer = createWorkServer();
-        const result = runOneShotWorker({
-          prompt,
-          systemPrompt: buildSleepDirective(agentContext),
-          workerServer,
-          model: config.model
-        });
-        for await (const _ of result) {
-        }
+        await runConsolidation();
       },
       config.sleepHour,
       config.timezone,