@integrity-labs/agt-cli 0.10.6 → 0.10.8

package/dist/lib/manager-worker.js

@@ -10,7 +10,7 @@ import {
   provisionStopHook,
   requireHost,
   resolveChannels
-} from "../chunk-O5T62RSQ.js";
+} from "../chunk-VDUA5FEW.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -683,6 +683,9 @@ function clearAgentCaches(agentId, codeName) {
   lastHarvestAt.delete(codeName);
   claudeSchedulerStates.delete(codeName);
   claudeTaskConcurrency.delete(codeName);
+  memoryFileHashes.delete(agentId);
+  lastDownloadHash.delete(agentId);
+  lastLocalFileHash.delete(agentId);
   for (const key of knownChannelConfigHashes.keys()) {
     if (key.startsWith(`${agentId}:`)) knownChannelConfigHashes.delete(key);
   }
@@ -1703,8 +1706,15 @@ async function processAgent(agent, agentStates) {
           if (!pluginName) continue;
           const entry = refreshData.channel_configs[channelId];
           if (!entry || entry.status !== "active" && entry.status !== "pending") continue;
-          const pluginDir = join(homedir(), ".claude", "plugins", pluginName);
-          if (existsSync(pluginDir)) continue;
+          try {
+            const installedPath = join(homedir(), ".claude", "plugins", "installed_plugins.json");
+            if (existsSync(installedPath)) {
+              const installed = JSON.parse(readFileSync(installedPath, "utf-8"));
+              const pluginKeys = Object.keys(installed.plugins ?? {});
+              if (pluginKeys.some((k) => k.startsWith(`${pluginName}@`))) continue;
+            }
+          } catch {
+          }
           try {
             const { execFileSync: efs } = await import("child_process");
             const claudePath = efs("which", ["claude"], { timeout: 5e3 }).toString().trim();
@@ -2280,6 +2290,13 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
       }
     }
   }
+  if (frameworkId === "claude-code" && agent.status === "active") {
+    try {
+      await syncMemories(agent, config.configDir, log);
+    } catch (err) {
+      log(`Memory sync failed for '${agent.code_name}': ${err.message}`);
+    }
+  }
   agentStates.push({
     agentId: agent.agent_id,
     codeName: agent.code_name,
@@ -2472,6 +2489,12 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
   for (const task of ready) {
     if (inFlightClaudeTasks.has(task.taskId)) continue;
     if ((claudeTaskConcurrency.get(codeName) ?? 0) >= MAX_CLAUDE_CONCURRENCY) break;
+    if (KANBAN_WORK_TEMPLATES.has(task.templateId) && !hasActionableItems(boardItems)) {
+      log(`[claude-scheduler] Skipping '${task.name}' for '${codeName}' \u2014 board is empty`);
+      const updated = markTaskFired(codeName, task.taskId, "ok");
+      claudeSchedulerStates.set(codeName, updated);
+      continue;
+    }
     let prompt = task.prompt;
     if (BOARD_INJECT_TEMPLATES.has(task.templateId) && boardItems.length > 0) {
       const template = PLAN_TEMPLATES.has(task.templateId) ? "morning-plan" : "follow-up";
@@ -2746,6 +2769,12 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       log(`[persistent-session] ${ready.length} ready task(s) for '${codeName}': ${ready.map((t) => `${t.name}(next=${t.nextFireAt ? new Date(t.nextFireAt).toISOString() : "null"})`).join(", ")}`);
     }
     for (const task of ready) {
+      if (KANBAN_WORK_TEMPLATES.has(task.templateId) && !hasActionableItems(boardItems)) {
+        log(`[persistent-session] Skipping '${task.name}' for '${codeName}' \u2014 board is empty`);
+        const updated = markTaskFired(codeName, task.taskId, "ok");
+        claudeSchedulerStates.set(codeName, updated);
+        continue;
+      }
       let prompt = task.prompt;
       if (BOARD_INJECT_TEMPLATES.has(task.templateId) && boardItems.length > 0) {
         const template = PLAN_TEMPLATES.has(task.templateId) ? "morning-plan" : "follow-up";
@@ -3137,6 +3166,10 @@ var TASK_UPDATE_TEMPLATES = /* @__PURE__ */ new Set(["hourly-status", "task-upda
 var PLAN_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan"]);
 var KANBAN_WORK_TEMPLATES = /* @__PURE__ */ new Set(["kanban-work"]);
 var BOARD_INJECT_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan", "task-update", "hourly-status", "end-of-day-summary", "kanban-work"]);
+var ACTIONABLE_STATUSES = /* @__PURE__ */ new Set(["backlog", "today", "in_progress"]);
+function hasActionableItems(items) {
+  return items.some((item) => ACTIONABLE_STATUSES.has(item.status));
+}
 var lastHarvestAt = /* @__PURE__ */ new Map();
 var HARVEST_INTERVAL_MS = 3 * 60 * 1e3;
 var kanbanBoardCache = /* @__PURE__ */ new Map();
@@ -3820,6 +3853,118 @@ function generateArtifacts(agent, refreshData, adapter) {
   const provisionOutput = provision(provisionInput, adapter.id);
   return provisionOutput.artifacts;
 }
+var memoryFileHashes = /* @__PURE__ */ new Map();
+var lastDownloadHash = /* @__PURE__ */ new Map();
+var lastLocalFileHash = /* @__PURE__ */ new Map();
+function parseMemoryFile(raw, fallbackName) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const fmMatch = trimmed.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (fmMatch) {
+    const frontmatter = fmMatch[1] ?? "";
+    const body = (fmMatch[2] ?? "").trim();
+    if (!body) return null;
+    const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+    const typeMatch = frontmatter.match(/^type:\s*(.+)$/m);
+    const name = nameMatch?.[1]?.trim().replace(/^["']|["']$/g, "") ?? fallbackName;
+    const rawType = typeMatch?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "user";
+    const typeMap = { user: "user", feedback: "feedback", project: "project", reference: "reference", daily: "daily" };
+    const type = typeMap[rawType] ?? "user";
+    return { name, content: body, type };
+  }
+  const isDaily = /^\d{4}-\d{2}-\d{2}$/.test(fallbackName);
+  return {
+    name: fallbackName,
+    content: trimmed,
+    type: isDaily ? "daily" : "project"
+  };
+}
+async function syncMemories(agent, configDir, log2) {
+  const projectDir = join(configDir, agent.code_name, "project");
+  const memoryDir = join(projectDir, "memory");
+  if (existsSync(memoryDir)) {
+    const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
+    const currentHashes = /* @__PURE__ */ new Map();
+    const changedMemories = [];
+    for (const file of readdirSync(memoryDir)) {
+      if (!file.endsWith(".md")) continue;
+      try {
+        const raw = readFileSync(join(memoryDir, file), "utf-8");
+        const fileHash = createHash("sha256").update(raw).digest("hex").slice(0, 16);
+        currentHashes.set(file, fileHash);
+        if (prevHashes.get(file) === fileHash) continue;
+        const parsed = parseMemoryFile(raw, file.replace(/\.md$/, ""));
+        if (parsed) {
+          if (parsed.type === "daily") {
+            parsed.expires_at = new Date(Date.now() + 48 * 60 * 60 * 1e3).toISOString();
+          }
+          changedMemories.push(parsed);
+        }
+      } catch {
+      }
+    }
+    memoryFileHashes.set(agent.agent_id, currentHashes);
+    if (changedMemories.length > 0) {
+      try {
+        await api.post("/host/sync-memories", {
+          agent_id: agent.agent_id,
+          memories: changedMemories
+        });
+        log2(`Synced ${changedMemories.length} changed memories to DB for '${agent.code_name}'`);
+      } catch (err) {
+        for (const mem of changedMemories) {
+          for (const [file] of currentHashes) {
+            const parsed = parseMemoryFile(readFileSync(join(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            if (parsed?.name === mem.name) currentHashes.delete(file);
+          }
+        }
+        log2(`Memory upload failed for '${agent.code_name}': ${err.message}`);
+      }
+    }
+  }
+  const localFiles = existsSync(memoryDir) ? readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localListHash = createHash("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
+  const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
+  const prevDownload = lastDownloadHash.get(agent.agent_id);
+  try {
+    const dbMemories = await api.post("/host/memories", {
+      agent_id: agent.agent_id
+    });
+    const responseHash = createHash("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
+    if (prevDownload && prevLocalHash === localListHash && lastDownloadHash.get(agent.agent_id) === responseHash) {
+      return;
+    }
+    lastDownloadHash.set(agent.agent_id, responseHash);
+    lastLocalFileHash.set(agent.agent_id, localListHash);
+    if (dbMemories.memories?.length) {
+      mkdirSync(memoryDir, { recursive: true });
+      const existingFileSet = new Set(localFiles.map((f) => f.replace(/\.md$/, "").toLowerCase()));
+      let written = 0;
+      for (const mem of dbMemories.memories) {
+        const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
+        const slug = rawSlug || `memory-${written}`;
+        if (existingFileSet.has(slug)) continue;
+        const fileContent = `---
+name: ${JSON.stringify(mem.name)}
+type: ${mem.type}
+description: ${JSON.stringify(mem.content.slice(0, 200))}
+---
+
+${mem.content}
+`;
+        writeFileSync(join(memoryDir, `${slug}.md`), fileContent);
+        written++;
+      }
+      if (written > 0) {
+        const updatedFiles = readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+        lastLocalFileHash.set(agent.agent_id, createHash("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
+        log2(`Exported ${written} DB memories to local files for '${agent.code_name}'`);
+      }
+    }
+  } catch (err) {
+    log2(`Memory download failed for '${agent.code_name}': ${err.message}`);
+  }
+}
 async function cleanupAgentFiles(codeName, agentDir) {
   if (existsSync(agentDir)) {
     try {