squads-cli 0.4.11 → 0.5.0

package/README.md

@@ -1,13 +1,22 @@
 # squads-cli
 
 [![npm version](https://img.shields.io/npm/v/squads-cli)](https://www.npmjs.com/package/squads-cli)
+[![npm downloads](https://img.shields.io/npm/dw/squads-cli)](https://www.npmjs.com/package/squads-cli)
+[![GitHub stars](https://img.shields.io/github/stars/agents-squads/squads-cli?style=social)](https://github.com/agents-squads/squads-cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
-[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
 
-**Organize, run, and track autonomous AI agents.** Built for Claude Code.
+**Open source CLI for AI agent coordination.** Organize agents into domain-aligned squads with persistent memory, goal tracking, and coordinated execution.
+
+```bash
+npm install -g squads-cli && squads init
+```
+
+> **Why squads?** AI agents are powerful alone, but real work needs coordination. Squads organizes agents by business domain, gives them persistent memory, tracks goals, and delivers outcomes—not just answers. Works with any AI coding assistant.
 
 ![squads dashboard](./assets/dashboard.png)
 
+⭐ **If you find this useful, [star the repo](https://github.com/agents-squads/squads-cli)** — it helps others discover it!
+
 ```
 $ squads status
 
@@ -29,13 +38,24 @@ $ squads status
 
 ## Why squads-cli?
 
-AI agents are powerful individually. But real work requires coordination.
+| Other Frameworks | squads-cli |
+|------------------|------------|
+| Framework lock-in | Markdown files you own |
+| Complex setup | `npm install -g` and go |
+| No memory | Persistent state across sessions |
+| Single agent focus | Domain-aligned teams |
+| Code-heavy | CLI-first, zero code to start |
+
+**Works with:** Claude Code, Cursor, Aider, Gemini, GitHub Copilot, and more.
+
+## Key Features
 
 - **Squads** — Group agents by domain (engineering, research, marketing)
 - **Memory** — Persistent state that survives across sessions
 - **Goals** — Track objectives and measure progress
 - **Sessions** — Real-time detection of running AI assistants
-- **Stack** — Local infrastructure for telemetry and memory
+- **Hooks** — Inject context at session start, sync memory at session end
+- **Stack** — Optional local infrastructure for telemetry and cost tracking
 
 No complex infrastructure. Just markdown files and a CLI.
 

package/dist/{chunk-HIQ2APYR.js → chunk-7PRYDHZW.js}

@@ -604,7 +604,7 @@ async function sessionsSummaryCommand(data, options = {}) {
 async function buildCurrentSessionSummary() {
   const { existsSync: existsSync2, readdirSync: readdirSync2, statSync, readFileSync: readFileSync2 } = await import("fs");
   const { join: join2 } = await import("path");
-  const { findMemoryDir } = await import("./memory-4PVUKIDK.js");
+  const { findMemoryDir } = await import("./memory-ZXDXF6KF.js");
   const memoryDir = findMemoryDir();
   const squads = [];
   const filesUpdated = [];
@@ -764,4 +764,4 @@ export {
   buildCurrentSessionSummary,
   sessionsHistoryCommand
 };
-//# sourceMappingURL=chunk-HIQ2APYR.js.map
+//# sourceMappingURL=chunk-7PRYDHZW.js.map

package/dist/chunk-BV6S5AWZ.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-7OCVIDC7.js";
+
+// src/lib/memory.ts
+import { readFileSync, writeFileSync as writeFileSync2, existsSync as existsSync2, readdirSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+
+// src/lib/lock.ts
+import Redis from "ioredis";
+import { existsSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { createHash } from "crypto";
+var LOCK_TTL_MS = 3e4;
+var LOCK_RETRY_DELAY_MS = 100;
+var LOCK_MAX_RETRIES = 50;
+var redisClient = null;
+var redisAvailable = null;
+async function getRedis() {
+  if (redisAvailable === false) return null;
+  if (!redisClient) {
+    try {
+      redisClient = new Redis({
+        host: process.env.REDIS_HOST || "localhost",
+        port: parseInt(process.env.REDIS_PORT || "6379"),
+        connectTimeout: 1e3,
+        maxRetriesPerRequest: 1,
+        lazyConnect: true
+      });
+      await redisClient.connect();
+      redisAvailable = true;
+    } catch {
+      redisAvailable = false;
+      redisClient = null;
+      return null;
+    }
+  }
+  return redisClient;
+}
+function generateLockId() {
+  return `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function getLockKey(filePath) {
+  const hash = createHash("md5").update(filePath).digest("hex").slice(0, 12);
+  return `squads:lock:${hash}`;
+}
+function getFileLockPath(filePath) {
+  const lockDir = join(dirname(filePath), ".locks");
+  const hash = createHash("md5").update(filePath).digest("hex").slice(0, 12);
+  return join(lockDir, `${hash}.lock`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function acquireRedisLock(key, lockId) {
+  const redis = await getRedis();
+  if (!redis) return false;
+  try {
+    const result = await redis.set(key, lockId, "PX", LOCK_TTL_MS, "NX");
+    return result === "OK";
+  } catch {
+    return false;
+  }
+}
+async function releaseRedisLock(key, lockId) {
+  const redis = await getRedis();
+  if (!redis) return false;
+  try {
+    const script = `
+      if redis.call("get", KEYS[1]) == ARGV[1] then
+        return redis.call("del", KEYS[1])
+      else
+        return 0
+      end
+    `;
+    const result = await redis.eval(script, 1, key, lockId);
+    return result === 1;
+  } catch {
+    return false;
+  }
+}
+function acquireFileLock(lockPath, lockId) {
+  try {
+    const lockDir = dirname(lockPath);
+    if (!existsSync(lockDir)) {
+      mkdirSync(lockDir, { recursive: true });
+    }
+    if (existsSync(lockPath)) {
+      const { statSync, readFileSync: readFileSync2 } = __require("fs");
+      const stats = statSync(lockPath);
+      const ageMs = Date.now() - stats.mtimeMs;
+      if (ageMs > LOCK_TTL_MS) {
+        unlinkSync(lockPath);
+      } else {
+        return false;
+      }
+    }
+    const { openSync, closeSync } = __require("fs");
+    const fd = openSync(lockPath, "wx");
+    writeFileSync(fd, lockId);
+    closeSync(fd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseFileLock(lockPath, lockId) {
+  try {
+    if (!existsSync(lockPath)) return true;
+    const { readFileSync: readFileSync2 } = __require("fs");
+    const currentId = readFileSync2(lockPath, "utf-8").trim();
+    if (currentId === lockId) {
+      unlinkSync(lockPath);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function acquireLock(filePath) {
+  const lockId = generateLockId();
+  const redisKey = getLockKey(filePath);
+  const fileLockPath = getFileLockPath(filePath);
+  let useRedis = false;
+  for (let attempt = 0; attempt < LOCK_MAX_RETRIES; attempt++) {
+    if (await acquireRedisLock(redisKey, lockId)) {
+      useRedis = true;
+      break;
+    }
+    if (redisAvailable === false && acquireFileLock(fileLockPath, lockId)) {
+      useRedis = false;
+      break;
+    }
+    if (attempt < LOCK_MAX_RETRIES - 1) {
+      await sleep(LOCK_RETRY_DELAY_MS);
+    }
+  }
+  const redis = await getRedis();
+  let gotLock = false;
+  if (redis) {
+    try {
+      const currentOwner = await redis.get(redisKey);
+      gotLock = currentOwner === lockId;
+    } catch {
+      gotLock = false;
+    }
+  } else {
+    try {
+      if (existsSync(fileLockPath)) {
+        const { readFileSync: readFileSync2 } = __require("fs");
+        const currentId = readFileSync2(fileLockPath, "utf-8").trim();
+        gotLock = currentId === lockId;
+      }
+    } catch {
+      gotLock = false;
+    }
+  }
+  if (!gotLock) {
+    return null;
+  }
+  return async () => {
+    if (useRedis) {
+      await releaseRedisLock(redisKey, lockId);
+    } else {
+      releaseFileLock(fileLockPath, lockId);
+    }
+  };
+}
+async function withLock(filePath, fn) {
+  const release = await acquireLock(filePath);
+  if (!release) {
+    throw new Error(`Failed to acquire lock for: ${filePath}`);
+  }
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
+// src/lib/memory.ts
+function findMemoryDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const memoryPath = join2(dir, ".agents", "memory");
+    if (existsSync2(memoryPath)) {
+      return memoryPath;
+    }
+    const parent = join2(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function listMemoryEntries(memoryDir) {
+  const entries = [];
+  const squads = readdirSync(memoryDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  for (const squad of squads) {
+    const squadPath = join2(memoryDir, squad);
+    const agents = readdirSync(squadPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const agent of agents) {
+      const agentPath = join2(squadPath, agent);
+      const files = readdirSync(agentPath).filter((f) => f.endsWith(".md"));
+      for (const file of files) {
+        const filePath = join2(agentPath, file);
+        const type = file.replace(".md", "");
+        entries.push({
+          squad,
+          agent,
+          type,
+          content: readFileSync(filePath, "utf-8"),
+          path: filePath
+        });
+      }
+    }
+  }
+  return entries;
+}
+var SEMANTIC_EXPANSIONS = {
+  "pricing": ["price", "cost", "$", "revenue", "fee", "rate"],
+  "price": ["pricing", "cost", "$", "fee"],
+  "revenue": ["income", "sales", "mrr", "arr", "$"],
+  "cost": ["expense", "spend", "budget", "$", "price"],
+  "customer": ["client", "lead", "prospect", "user"],
+  "client": ["customer", "lead", "prospect"],
+  "lead": ["prospect", "customer", "client", "pipeline"],
+  "agent": ["squad", "bot", "ai"],
+  "squad": ["team", "agent", "group"],
+  "status": ["state", "progress", "health"],
+  "bug": ["issue", "error", "problem", "fix"],
+  "feature": ["capability", "function", "ability"]
+};
+function expandQuery(query) {
+  const words = query.toLowerCase().split(/\s+/);
+  const expanded = new Set(words);
+  for (const word of words) {
+    if (SEMANTIC_EXPANSIONS[word]) {
+      SEMANTIC_EXPANSIONS[word].forEach((syn) => expanded.add(syn));
+    }
+  }
+  return Array.from(expanded);
+}
+function getFileAge(filePath) {
+  try {
+    const { statSync } = __require("fs");
+    const stats = statSync(filePath);
+    const ageMs = Date.now() - stats.mtimeMs;
+    const ageDays = ageMs / (1e3 * 60 * 60 * 24);
+    return ageDays;
+  } catch {
+    return 999;
+  }
+}
+function searchMemory(query, memoryDir) {
+  const dir = memoryDir || findMemoryDir();
+  if (!dir) return [];
+  const entries = listMemoryEntries(dir);
+  const results = [];
+  const queryLower = query.toLowerCase();
+  const expandedTerms = expandQuery(queryLower);
+  for (const entry of entries) {
+    const contentLower = entry.content.toLowerCase();
+    const lines = entry.content.split("\n");
+    const matches = [];
+    let score = 0;
+    let directHits = 0;
+    let expandedHits = 0;
+    const directWords = queryLower.split(/\s+/);
+    for (const word of directWords) {
+      if (contentLower.includes(word)) {
+        directHits += 1;
+        score += 2;
+      }
+    }
+    for (const term of expandedTerms) {
+      if (contentLower.includes(term)) {
+        expandedHits += 1;
+        score += 0.5;
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (line.toLowerCase().includes(term) && line.trim() && !matches.includes(line.trim())) {
+            matches.push(line.trim());
+          }
+        }
+      }
+    }
+    if (contentLower.includes(queryLower)) {
+      score += 5;
+    }
+    const ageDays = getFileAge(entry.path);
+    if (ageDays < 1) {
+      score *= 1.5;
+    } else if (ageDays < 7) {
+      score *= 1.2;
+    } else if (ageDays > 30) {
+      score *= 0.8;
+    }
+    const typeWeights = {
+      "state": 1.2,
+      // Current state slightly preferred
+      "learnings": 1.1,
+      // Learnings are valuable
+      "output": 1,
+      // Recent outputs
+      "feedback": 0.9
+      // Feedback less commonly needed
+    };
+    score *= typeWeights[entry.type] || 1;
+    if (score > 0 && (directHits > 0 || expandedHits > 1)) {
+      results.push({ entry, matches: matches.slice(0, 7), score });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+function getSquadState(squadName) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return [];
+  const squadPath = join2(memoryDir, squadName);
+  if (!existsSync2(squadPath)) return [];
+  const entries = [];
+  const agents = readdirSync(squadPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  for (const agent of agents) {
+    const statePath = join2(squadPath, agent, "state.md");
+    if (existsSync2(statePath)) {
+      entries.push({
+        squad: squadName,
+        agent,
+        type: "state",
+        content: readFileSync(statePath, "utf-8"),
+        path: statePath
+      });
+    }
+  }
+  return entries;
+}
+async function updateMemory(squadName, agentName, type, content) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    throw new Error("No .agents/memory directory found");
+  }
+  const filePath = join2(memoryDir, squadName, agentName, `${type}.md`);
+  const dir = dirname2(filePath);
+  await withLock(filePath, () => {
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(filePath, content);
+  });
+}
+function updateMemorySync(squadName, agentName, type, content) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    throw new Error("No .agents/memory directory found");
+  }
+  const filePath = join2(memoryDir, squadName, agentName, `${type}.md`);
+  const dir = dirname2(filePath);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(filePath, content);
+}
+async function appendToMemory(squadName, agentName, type, addition) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    throw new Error("No .agents/memory directory found");
+  }
+  const filePath = join2(memoryDir, squadName, agentName, `${type}.md`);
+  await withLock(filePath, () => {
+    let existing = "";
+    if (existsSync2(filePath)) {
+      existing = readFileSync(filePath, "utf-8");
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const newContent = existing + `
+
+---
+_Added: ${timestamp}_
+
+${addition}`;
+    const dir = dirname2(filePath);
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(filePath, newContent.trim());
+  });
+}
+function appendToMemorySync(squadName, agentName, type, addition) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    throw new Error("No .agents/memory directory found");
+  }
+  const filePath = join2(memoryDir, squadName, agentName, `${type}.md`);
+  let existing = "";
+  if (existsSync2(filePath)) {
+    existing = readFileSync(filePath, "utf-8");
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const newContent = existing + `
+
+---
+_Added: ${timestamp}_
+
+${addition}`;
+  updateMemorySync(squadName, agentName, type, newContent.trim());
+}
+
+export {
+  findMemoryDir,
+  listMemoryEntries,
+  searchMemory,
+  getSquadState,
+  updateMemory,
+  updateMemorySync,
+  appendToMemory,
+  appendToMemorySync
+};
+//# sourceMappingURL=chunk-BV6S5AWZ.js.map

package/dist/chunk-BV6S5AWZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/memory.ts","../src/lib/lock.ts"],"sourcesContent":["import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';\nimport { join, dirname } from 'path';\nimport { withLock } from './lock.js';\n\nexport interface MemoryEntry {\n  squad: string;\n  agent: string;\n  type: 'state' | 'output' | 'learnings' | 'feedback';\n  content: string;\n  path: string;\n  lastUpdated?: string;\n}\n\nexport interface SearchResult {\n  entry: MemoryEntry;\n  matches: string[];\n  score: number;\n}\n\nexport function findMemoryDir(): string | null {\n  let dir = process.cwd();\n\n  for (let i = 0; i < 5; i++) {\n    const memoryPath = join(dir, '.agents', 'memory');\n    if (existsSync(memoryPath)) {\n      return memoryPath;\n    }\n    const parent = join(dir, '..');\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  return null;\n}\n\nexport function listMemoryEntries(memoryDir: string): MemoryEntry[] {\n  const entries: MemoryEntry[] = [];\n\n  const squads = readdirSync(memoryDir, { withFileTypes: true })\n    .filter(e => e.isDirectory())\n    .map(e => e.name);\n\n  for (const squad of squads) {\n    const squadPath = join(memoryDir, squad);\n    const agents = readdirSync(squadPath, { withFileTypes: true })\n      .filter(e => e.isDirectory())\n      .map(e => e.name);\n\n    for (const agent of agents) {\n      const agentPath = join(squadPath, agent);\n      const files = readdirSync(agentPath).filter(f => f.endsWith('.md'));\n\n      for (const file of files) {\n        const filePath = join(agentPath, file);\n        const type = file.replace('.md', '') as MemoryEntry['type'];\n\n        entries.push({\n          squad,\n          agent,\n          type,\n          content: readFileSync(filePath, 'utf-8'),\n          path: filePath\n        });\n      }\n    }\n  }\n\n  return entries;\n}\n\n// Semantic expansions for common business terms\nconst SEMANTIC_EXPANSIONS: Record<string, string[]> = {\n  'pricing': ['price', 'cost', '$', 'revenue', 'fee', 'rate'],\n  'price': ['pricing', 'cost', '$', 'fee'],\n  'revenue': ['income', 'sales', 'mrr', 'arr', '$'],\n  'cost': ['expense', 'spend', 'budget', '$', 'price'],\n  'customer': ['client', 'lead', 'prospect', 'user'],\n  'client': ['customer', 'lead', 'prospect'],\n  'lead': ['prospect', 'customer', 'client', 'pipeline'],\n  'agent': ['squad', 'bot', 'ai'],\n  'squad': ['team', 'agent', 'group'],\n  'status': ['state', 'progress', 'health'],\n  'bug': ['issue', 'error', 'problem', 'fix'],\n  'feature': ['capability', 'function', 'ability'],\n};\n\nfunction expandQuery(query: string): string[] {\n  const words = query.toLowerCase().split(/\\s+/);\n  const expanded = new Set(words);\n\n  for (const word of words) {\n    if (SEMANTIC_EXPANSIONS[word]) {\n      SEMANTIC_EXPANSIONS[word].forEach(syn => expanded.add(syn));\n    }\n  }\n\n  return Array.from(expanded);\n}\n\nfunction getFileAge(filePath: string): number {\n  try {\n    const { statSync } = require('fs');\n    const stats = statSync(filePath);\n    const ageMs = Date.now() - stats.mtimeMs;\n    const ageDays = ageMs / (1000 * 60 * 60 * 24);\n    return ageDays;\n  } catch {\n    return 999;\n  }\n}\n\nexport function searchMemory(query: string, memoryDir?: string): SearchResult[] {\n  const dir = memoryDir || findMemoryDir();\n  if (!dir) return [];\n\n  const entries = listMemoryEntries(dir);\n  const results: SearchResult[] = [];\n  const queryLower = query.toLowerCase();\n  const expandedTerms = expandQuery(queryLower);\n\n  for (const entry of entries) {\n    const contentLower = entry.content.toLowerCase();\n    const lines = entry.content.split('\\n');\n    const matches: string[] = [];\n    let score = 0;\n    let directHits = 0;\n    let expandedHits = 0;\n\n    // Check direct query words first\n    const directWords = queryLower.split(/\\s+/);\n    for (const word of directWords) {\n      if (contentLower.includes(word)) {\n        directHits += 1;\n        score += 2; // Direct matches worth more\n      }\n    }\n\n    // Check expanded terms\n    for (const term of expandedTerms) {\n      if (contentLower.includes(term)) {\n        expandedHits += 1;\n        score += 0.5; // Expanded matches worth less but still count\n\n        // Find matching lines with context\n        for (let i = 0; i < lines.length; i++) {\n          const line = lines[i];\n          if (line.toLowerCase().includes(term) && line.trim() && !matches.includes(line.trim())) {\n            matches.push(line.trim());\n          }\n        }\n      }\n    }\n\n    // Boost score for exact phrase match\n    if (contentLower.includes(queryLower)) {\n      score += 5;\n    }\n\n    // Recency boost - files updated recently are more relevant\n    const ageDays = getFileAge(entry.path);\n    if (ageDays < 1) {\n      score *= 1.5; // Updated today\n    } else if (ageDays < 7) {\n      score *= 1.2; // Updated this week\n    } else if (ageDays > 30) {\n      score *= 0.8; // Stale data penalty\n    }\n\n    // Type weighting - balanced across types\n    const typeWeights: Record<string, number> = {\n      'state': 1.2,      // Current state slightly preferred\n      'learnings': 1.1,  // Learnings are valuable\n      'output': 1.0,     // Recent outputs\n      'feedback': 0.9,   // Feedback less commonly needed\n    };\n    score *= typeWeights[entry.type] || 1.0;\n\n    if (score > 0 && (directHits > 0 || expandedHits > 1)) {\n      results.push({ entry, matches: matches.slice(0, 7), score });\n    }\n  }\n\n  // Sort by score descending\n  return results.sort((a, b) => b.score - a.score);\n}\n\nexport function getSquadState(squadName: string): MemoryEntry[] {\n  const memoryDir = findMemoryDir();\n  if (!memoryDir) return [];\n\n  const squadPath = join(memoryDir, squadName);\n  if (!existsSync(squadPath)) return [];\n\n  const entries: MemoryEntry[] = [];\n  const agents = readdirSync(squadPath, { withFileTypes: true })\n    .filter(e => e.isDirectory())\n    .map(e => e.name);\n\n  for (const agent of agents) {\n    const statePath = join(squadPath, agent, 'state.md');\n    if (existsSync(statePath)) {\n      entries.push({\n        squad: squadName,\n        agent,\n        type: 'state',\n        content: readFileSync(statePath, 'utf-8'),\n        path: statePath\n      });\n    }\n  }\n\n  return entries;\n}\n\n/**\n * Update memory file with distributed locking\n * Safe for concurrent access from multiple agents\n */\nexport async function updateMemory(\n  squadName: string,\n  agentName: string,\n  type: MemoryEntry['type'],\n  content: string\n): Promise<void> {\n  const memoryDir = findMemoryDir();\n  if (!memoryDir) {\n    throw new Error('No .agents/memory directory found');\n  }\n\n  const filePath = join(memoryDir, squadName, agentName, `${type}.md`);\n  const dir = dirname(filePath);\n\n  await withLock(filePath, () => {\n    if (!existsSync(dir)) {\n      mkdirSync(dir, { recursive: true });\n    }\n    writeFileSync(filePath, content);\n  });\n}\n\n/**\n * Sync version for backward compatibility (no locking - use with caution)\n * @deprecated Use async updateMemory() for safe concurrent access\n */\nexport function updateMemorySync(\n  squadName: string,\n  agentName: string,\n  type: MemoryEntry['type'],\n  content: string\n): void {\n  const memoryDir = findMemoryDir();\n  if (!memoryDir) {\n    throw new Error('No .agents/memory directory found');\n  }\n\n  const filePath = join(memoryDir, squadName, agentName, `${type}.md`);\n  const dir = dirname(filePath);\n\n  if (!existsSync(dir)) {\n    mkdirSync(dir, { recursive: true });\n  }\n\n  writeFileSync(filePath, content);\n}\n\n/**\n * Append to memory file with distributed locking\n * Safe for concurrent access from multiple agents\n */\nexport async function appendToMemory(\n  squadName: string,\n  agentName: string,\n  type: MemoryEntry['type'],\n  addition: string\n): Promise<void> {\n  const memoryDir = findMemoryDir();\n  if (!memoryDir) {\n    throw new Error('No .agents/memory directory found');\n  }\n\n  const filePath = join(memoryDir, squadName, agentName, `${type}.md`);\n\n  await withLock(filePath, () => {\n    let existing = '';\n    if (existsSync(filePath)) {\n      existing = readFileSync(filePath, 'utf-8');\n    }\n\n    const timestamp = new Date().toISOString().split('T')[0];\n    const newContent = existing + `\\n\\n---\\n_Added: ${timestamp}_\\n\\n${addition}`;\n\n    const dir = dirname(filePath);\n    if (!existsSync(dir)) {\n      mkdirSync(dir, { recursive: true });\n    }\n    writeFileSync(filePath, newContent.trim());\n  });\n}\n\n/**\n * Sync version for backward compatibility (no locking - use with caution)\n * @deprecated Use async appendToMemory() for safe concurrent access\n */\nexport function appendToMemorySync(\n  squadName: string,\n  agentName: string,\n  type: MemoryEntry['type'],\n  addition: string\n): void {\n  const memoryDir = findMemoryDir();\n  if (!memoryDir) {\n    throw new Error('No .agents/memory directory found');\n  }\n\n  const filePath = join(memoryDir, squadName, agentName, `${type}.md`);\n\n  let existing = '';\n  if (existsSync(filePath)) {\n    existing = readFileSync(filePath, 'utf-8');\n  }\n\n  const timestamp = new Date().toISOString().split('T')[0];\n  const newContent = existing + `\\n\\n---\\n_Added: ${timestamp}_\\n\\n${addition}`;\n\n  updateMemorySync(squadName, agentName, type, newContent.trim());\n}\n","/**\n * Distributed locking for safe concurrent file access\n * Uses Redis when available, falls back to file-based locks\n */\n\nimport Redis from 'ioredis';\nimport { existsSync, writeFileSync, unlinkSync, mkdirSync } from 'fs';\nimport { join, dirname } from 'path';\nimport { createHash } from 'crypto';\n\n// Lock configuration\nconst LOCK_TTL_MS = 30000; // 30 seconds max lock hold time\nconst LOCK_RETRY_DELAY_MS = 100;\nconst LOCK_MAX_RETRIES = 50; // 5 seconds max wait\n\n// Singleton Redis client\nlet redisClient: Redis | null = null;\nlet redisAvailable: boolean | null = null;\n\n/**\n * Get or create Redis client\n */\nasync function getRedis(): Promise<Redis | null> {\n  if (redisAvailable === false) return null;\n\n  if (!redisClient) {\n    try {\n      redisClient = new Redis({\n        host: process.env.REDIS_HOST || 'localhost',\n        port: parseInt(process.env.REDIS_PORT || '6379'),\n        connectTimeout: 1000,\n        maxRetriesPerRequest: 1,\n        lazyConnect: true,\n      });\n\n      await redisClient.connect();\n      redisAvailable = true;\n    } catch {\n      redisAvailable = false;\n      redisClient = null;\n      return null;\n    }\n  }\n\n  return redisClient;\n}\n\n/**\n * Generate a unique lock ID for this process\n */\nfunction generateLockId(): string {\n  return `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;\n}\n\n/**\n * Hash a file path to create a lock key\n */\nfunction getLockKey(filePath: string): string {\n  const hash = createHash('md5').update(filePath).digest('hex').slice(0, 12);\n  return `squads:lock:${hash}`;\n}\n\n/**\n * Get file lock path for fallback locking\n */\nfunction getFileLockPath(filePath: string): string {\n  const lockDir = join(dirname(filePath), '.locks');\n  const hash = createHash('md5').update(filePath).digest('hex').slice(0, 12);\n  return join(lockDir, `${hash}.lock`);\n}\n\n/**\n * Sleep helper\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * Acquire a distributed lock using Redis\n */\nasync function acquireRedisLock(key: string, lockId: string): Promise<boolean> {\n  const redis = await getRedis();\n  if (!redis) return false;\n\n  try {\n    // SET key lockId NX PX ttl - atomic set-if-not-exists with expiry\n    const result = await redis.set(key, lockId, 'PX', LOCK_TTL_MS, 'NX');\n    return result === 'OK';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Release a Redis lock (only if we own it)\n */\nasync function releaseRedisLock(key: string, lockId: string): Promise<boolean> {\n  const redis = await getRedis();\n  if (!redis) return false;\n\n  try {\n    // Lua script to atomically check and delete\n    const script = `\n      if redis.call(\"get\", KEYS[1]) == ARGV[1] then\n        return redis.call(\"del\", KEYS[1])\n      else\n        return 0\n      end\n    `;\n    const result = await redis.eval(script, 1, key, lockId);\n    return result === 1;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Acquire a file-based lock (fallback when Redis unavailable)\n */\nfunction acquireFileLock(lockPath: string, lockId: string): boolean {\n  try {\n    const lockDir = dirname(lockPath);\n    if (!existsSync(lockDir)) {\n      mkdirSync(lockDir, { recursive: true });\n    }\n\n    // Check if lock exists and is still valid\n    if (existsSync(lockPath)) {\n      const { statSync, readFileSync } = require('fs');\n      const stats = statSync(lockPath);\n      const ageMs = Date.now() - stats.mtimeMs;\n\n      // Lock expired - clean it up\n      if (ageMs > LOCK_TTL_MS) {\n        unlinkSync(lockPath);\n      } else {\n        return false; // Lock held by another process\n      }\n    }\n\n    // Create lock file atomically using O_EXCL flag\n    const { openSync, closeSync } = require('fs');\n    const fd = openSync(lockPath, 'wx');\n    writeFileSync(fd, lockId);\n    closeSync(fd);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Release a file-based lock\n */\nfunction releaseFileLock(lockPath: string, lockId: string): boolean {\n  try {\n    if (!existsSync(lockPath)) return true;\n\n    const { readFileSync } = require('fs');\n    const currentId = readFileSync(lockPath, 'utf-8').trim();\n\n    if (currentId === lockId) {\n      unlinkSync(lockPath);\n      return true;\n    }\n    return false;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Acquire a lock for a file path\n * Returns a release function, or null if lock couldn't be acquired\n */\nexport async function acquireLock(filePath: string): Promise<(() => Promise<void>) | null> {\n  const lockId = generateLockId();\n  const redisKey = getLockKey(filePath);\n  const fileLockPath = getFileLockPath(filePath);\n\n  let useRedis = false;\n\n  for (let attempt = 0; attempt < LOCK_MAX_RETRIES; attempt++) {\n    // Try Redis first\n    if (await acquireRedisLock(redisKey, lockId)) {\n      useRedis = true;\n      break;\n    }\n\n    // Fall back to file lock if Redis unavailable\n    if (redisAvailable === false && acquireFileLock(fileLockPath, lockId)) {\n      useRedis = false;\n      break;\n    }\n\n    // Wait and retry\n    if (attempt < LOCK_MAX_RETRIES - 1) {\n      await sleep(LOCK_RETRY_DELAY_MS);\n    }\n  }\n\n  // Check if we got the lock\n  const redis = await getRedis();\n  let gotLock = false;\n\n  if (redis) {\n    try {\n      const currentOwner = await redis.get(redisKey);\n      gotLock = currentOwner === lockId;\n    } catch {\n      gotLock = false;\n    }\n  } else {\n    // Check file lock\n    try {\n      if (existsSync(fileLockPath)) {\n        const { readFileSync } = require('fs');\n        const currentId = readFileSync(fileLockPath, 'utf-8').trim();\n        gotLock = currentId === lockId;\n      }\n    } catch {\n      gotLock = false;\n    }\n  }\n\n  if (!gotLock) {\n    return null;\n  }\n\n  // Return release function\n  return async () => {\n    if (useRedis) {\n      await releaseRedisLock(redisKey, lockId);\n    } else {\n      releaseFileLock(fileLockPath, lockId);\n    }\n  };\n}\n\n/**\n * Execute a function while holding a lock\n * Automatically acquires and releases the lock\n */\nexport async function withLock<T>(\n  filePath: string,\n  fn: () => T | Promise<T>\n): Promise<T> {\n  const release = await acquireLock(filePath);\n\n  if (!release) {\n    throw new Error(`Failed to acquire lock for: ${filePath}`);\n  }\n\n  try {\n    return await fn();\n  } finally {\n    await release();\n  }\n}\n\n/**\n * Graceful shutdown - close Redis connection\n */\nexport async function closeLockClient(): Promise<void> {\n  if (redisClient) {\n    await redisClient.quit();\n    redisClient = null;\n    redisAvailable = null;\n  }\n}\n"],"mappings":"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","names":["writeFileSync","existsSync","mkdirSync","join","dirname","readFileSync","join","existsSync","dirname","mkdirSync","writeFileSync"]}