@slock-ai/daemon 0.25.0 → 0.27.0

package/dist/index.js

@@ -98,15 +98,17 @@ function toolRef(prefix, name) {
 }
 function buildBaseSystemPrompt(config, opts) {
   const t = (name) => toolRef(opts.toolPrefix, name);
+  const messageDeliveryText = opts.includeStdinNotificationSection ? "New messages will be delivered to you automatically via stdin." : "The daemon will automatically restart you when new messages arrive.";
   const criticalRules = [
     `- Do NOT output text directly. ALL communication goes through ${t("send_message")}.`,
     ...opts.extraCriticalRules,
-    `- Do NOT explore the filesystem looking for messaging scripts. The MCP tools are already available.`
+    `- Do NOT explore the filesystem looking for messaging scripts. The MCP tools are already available.`,
+    `- NEVER start working on a task without claiming it first via ${t("claim_tasks")}. If the claim fails, do NOT work on it.`
   ];
   const startupSteps = [
-    `1. **Read MEMORY.md** (in your cwd). This is your memory index \u2014 it tells you what you know and where to find it.`,
-    `2. Follow the instructions in MEMORY.md to read any other memory files you need (e.g. channel summaries, role definitions, user preferences).`,
-    `3. Stop and wait. New messages will be delivered to you automatically via stdin.`,
+    `1. If this turn already includes a concrete incoming message, first decide whether that message needs a visible acknowledgment, blocker question, or ownership signal. If it does, send it early with ${t("send_message")} before deep context gathering.`,
+    `2. Read MEMORY.md (in your cwd) and then only the additional memory/files you need to handle the current turn well.`,
+    `3. If there is no concrete incoming message to handle, stop and wait. ${messageDeliveryText}`,
     `4. When you receive a message, process it and reply with ${t("send_message")}.`,
     `5. **Complete ALL your work before stopping.** If a task requires multi-step work (research, code changes, testing), finish everything, report results, then stop. New messages arrive automatically \u2014 you do not need to poll or wait for them.`
   ];
@@ -217,7 +219,7 @@ Each channel has a task board with two independent dimensions: **status** (progr
 - **Unclaim**: \`unclaim_task(channel="#channel-name", task_number=3)\` \u2014 remove your assignment. Does not change progress status.
 - **Update status**: \`update_task_status(channel="#channel-name", task_number=3, status="in_review")\` \u2014 move a task to a new status. Valid transitions: todo\u2192in_progress, in_progress\u2192in_review, in_progress\u2192done, in_review\u2192done, in_review\u2192in_progress.
 
-**CRITICAL: You MUST claim a task before starting work on it.** Never begin working on a task without claiming it first. The claim mechanism prevents multiple agents from doing the same work. If your claim fails (someone else claimed it), move on to another task.
+**CRITICAL: You MUST claim a task before starting ANY work on it.** Call \`${t("claim_tasks")}\` first. If the claim fails (someone else already claimed it), you MUST NOT work on that task \u2014 move on to another one. This is the only way to prevent duplicate work across agents. No exceptions.
 
 **IMPORTANT: When you finish a task, use \`update_task_status(..., status="in_review")\`.** This gives humans a chance to validate your work before it's marked as done. Only set status to \`done\` directly for trivial tasks that don't need review.
 
@@ -250,7 +252,7 @@ Keep the user informed. They cannot see your internal reasoning, so:
 
 - **Don't interrupt ongoing conversations.** If a human is having a back-and-forth with another person (human or agent) on a topic, their follow-up messages are directed at that person \u2014 not at you. Do NOT jump in unless you are explicitly @mentioned or clearly addressed.
 - **Only the person doing the work should report on it.** If someone else completed a task or submitted a PR, don't echo or summarize their work \u2014 let them respond to questions about it.
-- **Claim before you start.** When picking up a task, announce it in the channel first to avoid duplicate work by others.
+- **Claim before you start.** Always call \`${t("claim_tasks")}\` before doing any work on a task. If the claim fails, stop immediately and pick a different task.
 
 ### Formatting \u2014 No HTML
 
@@ -801,28 +803,48 @@ function toLocalTime(iso) {
   const pad = (n) => String(n).padStart(2, "0");
   return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
 }
+function formatChannelLabel(message) {
+  return message.channel_type === "dm" ? `DM:@${message.channel_name}` : `#${message.channel_name}`;
+}
+function buildUnreadSummary(messages, excludeChannel) {
+  const summary = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const label = formatChannelLabel(message);
+    if (excludeChannel && label === excludeChannel) continue;
+    summary.set(label, (summary.get(label) || 0) + 1);
+  }
+  return summary.size > 0 ? Object.fromEntries(summary) : void 0;
+}
 var MAX_TRAJECTORY_TEXT = 2e3;
 var ACTIVITY_HEARTBEAT_MS = 6e4;
-var AgentProcessManager = class {
+function getMessageDeliveryText(supportsStdinNotification) {
+  return supportsStdinNotification ? "New messages will be delivered to you automatically via stdin." : "The daemon will automatically restart you when new messages arrive.";
+}
+var AgentProcessManager = class _AgentProcessManager {
   agents = /* @__PURE__ */ new Map();
   agentsStarting = /* @__PURE__ */ new Set();
   // Prevent concurrent starts of same agent
+  startingInboxes = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
   chatBridgePath;
   sendToServer;
   daemonApiKey;
-  constructor(chatBridgePath2, sendToServer, daemonApiKey) {
+  dataDir;
+  driverResolver;
+  constructor(chatBridgePath2, sendToServer, daemonApiKey, opts = {}) {
     this.chatBridgePath = chatBridgePath2;
     this.sendToServer = sendToServer;
     this.daemonApiKey = daemonApiKey;
+    this.dataDir = opts.dataDir || DATA_DIR;
+    this.driverResolver = opts.driverResolver || getDriver;
   }
-  async startAgent(agentId, config, wakeMessage, unreadSummary) {
+  async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt) {
     if (this.agents.has(agentId) || this.agentsStarting.has(agentId)) return;
     this.agentsStarting.add(agentId);
     try {
-      const driver = getDriver(config.runtime || "claude");
-      const agentDataDir = path3.join(DATA_DIR, agentId);
+      const driver = this.driverResolver(config.runtime || "claude");
+      const agentDataDir = path3.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
       const memoryMdPath = path3.join(agentDataDir, "MEMORY.md");
       try {
@@ -845,7 +867,14 @@ ${config.description || "No role defined yet."}
       await mkdir(path3.join(agentDataDir, "notes"), { recursive: true });
       const isResume = !!config.sessionId;
       let prompt;
-      if (isResume && wakeMessage) {
+      if (isResume && resumePrompt) {
+        prompt = resumePrompt;
+        if (driver.supportsStdinNotification) {
+          prompt += `
+
+Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.`;
+        }
+      } else if (isResume && wakeMessage) {
         const channelLabel = wakeMessage.channel_type === "dm" ? `DM:@${wakeMessage.channel_name}` : `#${wakeMessage.channel_name}`;
         const senderPrefix = wakeMessage.sender_type === "agent" ? "(agent) " : "";
         const time = wakeMessage.timestamp ? ` (${toLocalTime(wakeMessage.timestamp)})` : "";
@@ -872,7 +901,7 @@ Use read_history to catch up, or respond to the message above first.`;
 
 Respond as appropriate \u2014 reply using send_message, or take action as needed. Complete ALL your work before stopping.
 
-IMPORTANT: If the message requires multi-step work (e.g. research, code changes, testing), complete ALL steps before stopping. Sending a progress update does NOT mean your task is done \u2014 only stop when you have NO more work to do. New messages will be delivered to you automatically via stdin.`;
+IMPORTANT: If the message requires multi-step work (e.g. research, code changes, testing), complete ALL steps before stopping. Sending a progress update does NOT mean your task is done \u2014 only stop when you have NO more work to do. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
         if (driver.supportsStdinNotification) {
           prompt += `
 
@@ -886,14 +915,9 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
         }
         prompt += `
 
-Use read_history to catch up on important channels, then stop. New messages will be delivered to you automatically.`;
-        if (driver.supportsStdinNotification) {
-          prompt += `
-
-Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.`;
-        }
+Use read_history to catch up on the channels listed above, then stop. Read each listed channel at most once unless a read fails. Do NOT call check_messages in this mode. If the history reveals a direct request, assignment, @mention, review request, or task clearly addressed to you, switch into active handling instead of stopping: reply with send_message and claim the relevant task before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
       } else if (isResume) {
-        prompt = `No new messages while you were away. Nothing to do \u2014 just stop. New messages will be delivered to you automatically via stdin.`;
+        prompt = `No new messages while you were away. Nothing to do \u2014 just stop. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
         if (driver.supportsStdinNotification) {
           prompt += `
 
@@ -913,7 +937,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       const agentProcess = {
         process: proc,
         driver,
-        inbox: [],
+        inbox: this.startingInboxes.get(agentId) || [],
         config,
         sessionId: config.sessionId || null,
         isIdle: false,
@@ -923,6 +947,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         lastActivity: "",
         lastActivityDetail: ""
       };
+      this.startingInboxes.delete(agentId);
       this.agents.set(agentId, agentProcess);
       this.agentsStarting.delete(agentId);
       let buffer = "";
@@ -957,6 +982,26 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
           }
           this.agents.delete(agentId);
           if (code === 0) {
+            const queuedWakeMessage = !ap.driver.supportsStdinNotification ? ap.inbox.shift() : void 0;
+            const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
+            if (queuedWakeMessage) {
+              const nextConfig = { ...ap.config, sessionId: ap.sessionId };
+              this.idleAgentConfigs.set(agentId, {
+                config: nextConfig,
+                sessionId: ap.sessionId
+              });
+              this.broadcastActivity(agentId, "working", "Message received");
+              this.idleAgentConfigs.delete(agentId);
+              this.startAgent(agentId, nextConfig, queuedWakeMessage, unreadSummary2).catch((err) => {
+                console.error(`[Agent ${agentId}] Failed to continue with queued message:`, err);
+                this.idleAgentConfigs.set(agentId, {
+                  config: nextConfig,
+                  sessionId: ap.sessionId
+                });
+                this.broadcastActivity(agentId, "online", "Process idle");
+              });
+              return;
+            }
             this.idleAgentConfigs.set(agentId, {
               config: { ...ap.config, sessionId: ap.sessionId },
               sessionId: ap.sessionId
@@ -1017,6 +1062,12 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
   deliverMessage(agentId, message) {
     const ap = this.agents.get(agentId);
     if (!ap) {
+      if (this.agentsStarting.has(agentId)) {
+        const pending = this.startingInboxes.get(agentId) || [];
+        pending.push(message);
+        this.startingInboxes.set(agentId, pending);
+        return;
+      }
       const cached = this.idleAgentConfigs.get(agentId);
       if (cached) {
         console.log(`[Agent ${agentId}] Auto-restarting idle process for incoming message`);
@@ -1044,7 +1095,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     }
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path3.join(DATA_DIR, agentId);
+    const agentDataDir = path3.join(this.dataDir, agentId);
     try {
       await rm(agentDataDir, { recursive: true, force: true });
       console.log(`[Agent ${agentId}] Workspace deleted: ${agentDataDir}`);
@@ -1065,13 +1116,13 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     const results = [];
     let entries;
     try {
-      entries = await readdir(DATA_DIR, { withFileTypes: true });
+      entries = await readdir(this.dataDir, { withFileTypes: true });
     } catch {
       return [];
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const dirPath = path3.join(DATA_DIR, entry.name);
+      const dirPath = path3.join(this.dataDir, entry.name);
       try {
         const dirContents = await readdir(dirPath, { withFileTypes: true });
         let totalSize = 0;
@@ -1108,7 +1159,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     if (directoryName.includes("/") || directoryName.includes("..") || directoryName.includes("\\")) {
       return false;
     }
-    const targetDir = path3.join(DATA_DIR, directoryName);
+    const targetDir = path3.join(this.dataDir, directoryName);
     try {
       await rm(targetDir, { recursive: true, force: true });
       console.log(`[Workspace] Deleted directory: ${targetDir}`);
@@ -1120,7 +1171,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path3.join(DATA_DIR, agentId);
+    const agentDir = path3.join(this.dataDir, agentId);
     try {
       await stat(agentDir);
     } catch {
@@ -1137,7 +1188,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     return this.listDirectoryChildren(targetDir, agentDir);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path3.join(DATA_DIR, agentId);
+    const agentDir = path3.join(this.dataDir, agentId);
     const resolved = path3.resolve(agentDir, filePath);
     if (!resolved.startsWith(agentDir + path3.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
@@ -1171,6 +1222,102 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     const content = await readFile(resolved, "utf-8");
     return { content, binary: false };
   }
+  // Skill scanning
+  // Per-runtime skill search paths (relative to home dir for global, workspace dir for workspace).
+  // To add a new runtime, add an entry here.
+  static SKILL_PATHS = {
+    claude: {
+      // Claude reads shared skills via symlinks in ~/.claude/skills/, not from ~/.agents/skills/
+      global: [".claude/skills", ".claude/commands"],
+      workspace: [".claude/skills", ".claude/commands"]
+    },
+    codex: {
+      // Codex natively scans ~/.agents/skills/ and has built-in .system skills
+      global: [".codex/skills", ".codex/skills/.system", ".agents/skills"],
+      workspace: [".codex/skills", ".agents/skills"]
+    }
+  };
+  async listSkills(agentId, runtimeHint) {
+    const agent = this.agents.get(agentId);
+    const runtime = runtimeHint || agent?.config.runtime || "claude";
+    const home = os.homedir();
+    const workspaceDir = path3.join(this.dataDir, agentId);
+    const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
+    const globalResults = await Promise.all(
+      paths.global.map((p) => this.scanSkillsDir(path3.join(home, p)))
+    );
+    const workspaceResults = await Promise.all(
+      paths.workspace.map((p) => this.scanSkillsDir(path3.join(workspaceDir, p)))
+    );
+    const dedup = (skills) => {
+      const seen = /* @__PURE__ */ new Set();
+      return skills.filter((s) => {
+        if (seen.has(s.name)) return false;
+        seen.add(s.name);
+        return true;
+      });
+    };
+    const shorten = (skills) => skills.map((s) => ({
+      ...s,
+      sourcePath: s.sourcePath?.startsWith(home) ? "~" + s.sourcePath.slice(home.length) : s.sourcePath
+    }));
+    return {
+      global: shorten(dedup(globalResults.flat())),
+      workspace: shorten(dedup(workspaceResults.flat()))
+    };
+  }
+  async scanSkillsDir(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const skills = [];
+    for (const entry of entries) {
+      if (entry.isDirectory() || entry.isSymbolicLink()) {
+        const skillMd = path3.join(dir, entry.name, "SKILL.md");
+        try {
+          const content = await readFile(skillMd, "utf-8");
+          const skill = this.parseSkillMd(entry.name, content);
+          skill.sourcePath = dir;
+          skills.push(skill);
+        } catch {
+        }
+      } else if (entry.name.endsWith(".md")) {
+        const cmdName = entry.name.replace(/\.md$/, "");
+        try {
+          const content = await readFile(path3.join(dir, entry.name), "utf-8");
+          const skill = this.parseSkillMd(cmdName, content);
+          skill.sourcePath = dir;
+          skills.push(skill);
+        } catch {
+        }
+      }
+    }
+    return skills;
+  }
+  parseSkillMd(dirName, content) {
+    const info = {
+      name: dirName,
+      displayName: dirName,
+      description: "",
+      userInvocable: false
+    };
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return info;
+    const frontmatter = match[1];
+    for (const line of frontmatter.split("\n")) {
+      const colonIdx = line.indexOf(":");
+      if (colonIdx === -1) continue;
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      if (key === "name") info.displayName = value;
+      if (key === "description") info.description = value;
+      if (key === "user-invocable") info.userInvocable = value === "true";
+    }
+    return info;
+  }
   // Private methods
   /**
    * Broadcast an activity change — emits a single agent:activity event that carries
@@ -1419,7 +1566,7 @@ connection = new DaemonConnection({
     switch (msg.type) {
       case "agent:start":
         console.log(`[Daemon] Starting agent ${msg.agentId} (model: ${msg.config.model}, session: ${msg.config.sessionId || "new"}${msg.wakeMessage ? ", with wake message" : ""})`);
-        agentManager.startAgent(msg.agentId, msg.config, msg.wakeMessage, msg.unreadSummary).catch((err) => {
+        agentManager.startAgent(msg.agentId, msg.config, msg.wakeMessage, msg.unreadSummary, msg.resumePrompt).catch((err) => {
           const reason = err instanceof Error ? err.message : String(err);
           console.error(`[Daemon] Failed to start agent ${msg.agentId}:`, reason);
           connection.send({ type: "agent:status", agentId: msg.agentId, status: "inactive" });
@@ -1463,6 +1610,14 @@ connection = new DaemonConnection({
           });
         });
         break;
+      case "agent:skills:list":
+        agentManager.listSkills(msg.agentId, msg.runtime).then(({ global, workspace }) => {
+          connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global, workspace });
+        }).catch((err) => {
+          console.error(`[Daemon] Failed to list skills for ${msg.agentId}:`, err);
+          connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global: [], workspace: [] });
+        });
+        break;
       case "machine:workspace:scan":
         console.log("[Daemon] Scanning all workspace directories");
         agentManager.scanAllWorkspaces().then((directories) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"
@@ -32,6 +32,7 @@
     "dev": "tsx watch src/index.ts",
     "start": "tsx src/index.ts",
     "build": "tsup",
+    "test": "node --import tsx --test src/**/*.test.ts",
     "typecheck": "tsc --noEmit",
     "release:patch": "npm version patch --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:minor": "npm version minor --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",