@integrity-labs/agt-cli 0.10.5 → 0.10.7

package/dist/lib/manager-worker.js

@@ -10,7 +10,7 @@ import {
   provisionStopHook,
   requireHost,
   resolveChannels
-} from "../chunk-R2DDHROT.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,13 +1706,20 @@ 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();
             if (claudePath) {
-              efs(claudePath, ["plugin", "add", pluginName], {
+              efs(claudePath, ["plugin", "install", pluginName], {
                 timeout: 3e4,
                 stdio: "pipe"
               });
@@ -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,
@@ -3813,11 +3830,123 @@ function generateArtifacts(agent, refreshData, adapter) {
     timezone: agentTimezone,
     reportsTo,
     personalitySeed,
-    knowledge: (refreshData.knowledge ?? []).filter((k) => !!k.content)
+    knowledge: (refreshData.knowledge ?? []).filter((k) => !!k.content),
+    teamMembers: refreshData.team_members ?? void 0,
+    people: refreshData.people ?? void 0
   };
   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, hash] of currentHashes) {
+            const parsed = parseMemoryFile(readFileSync(join(memoryDir, file), "utf-8"), "");
+            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);
+  if (prevDownload && prevLocalHash === localListHash) return;
+  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);
+    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 {