opencode-swarm-plugin 0.1.0 → 0.2.0

package/dist/index.js

@@ -12879,6 +12879,242 @@ var beadsTools = {
   beads_link_thread
 };
 
+// src/tool-availability.ts
+var toolCache = new Map;
+var warningsLogged = new Set;
+async function commandExists(cmd) {
+  try {
+    const result = await Bun.$`which ${cmd}`.quiet().nothrow();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function urlReachable(url2, timeoutMs = 1000) {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const response = await fetch(url2, {
+      method: "HEAD",
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+var toolCheckers = {
+  "semantic-memory": async () => {
+    const nativeExists = await commandExists("semantic-memory");
+    if (nativeExists) {
+      try {
+        const result = await Bun.$`semantic-memory stats`.quiet().nothrow();
+        return {
+          available: result.exitCode === 0,
+          checkedAt: new Date().toISOString(),
+          version: "native"
+        };
+      } catch (e) {
+        return {
+          available: false,
+          checkedAt: new Date().toISOString(),
+          error: String(e)
+        };
+      }
+    }
+    try {
+      const proc = Bun.spawn(["bunx", "semantic-memory", "stats"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const timeout = setTimeout(() => proc.kill(), 1e4);
+      const exitCode = await proc.exited;
+      clearTimeout(timeout);
+      return {
+        available: exitCode === 0,
+        checkedAt: new Date().toISOString(),
+        version: "bunx"
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
+  cass: async () => {
+    const exists = await commandExists("cass");
+    if (!exists) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: "cass command not found"
+      };
+    }
+    try {
+      const result = await Bun.$`cass health`.quiet().nothrow();
+      return {
+        available: result.exitCode === 0,
+        checkedAt: new Date().toISOString()
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
+  ubs: async () => {
+    const exists = await commandExists("ubs");
+    if (!exists) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: "ubs command not found"
+      };
+    }
+    try {
+      const result = await Bun.$`ubs doctor`.quiet().nothrow();
+      return {
+        available: result.exitCode === 0,
+        checkedAt: new Date().toISOString()
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
+  beads: async () => {
+    const exists = await commandExists("bd");
+    if (!exists) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: "bd command not found"
+      };
+    }
+    try {
+      const result = await Bun.$`bd --version`.quiet().nothrow();
+      return {
+        available: result.exitCode === 0,
+        checkedAt: new Date().toISOString()
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
+  "agent-mail": async () => {
+    const reachable = await urlReachable("http://127.0.0.1:8765/health/liveness");
+    return {
+      available: reachable,
+      checkedAt: new Date().toISOString(),
+      error: reachable ? undefined : "Agent Mail server not reachable at :8765"
+    };
+  }
+};
+var fallbackBehaviors = {
+  "semantic-memory": "Learning data stored in-memory only (lost on session end)",
+  cass: "Decomposition proceeds without historical context from past sessions",
+  ubs: "Subtask completion skips bug scanning - manual review recommended",
+  beads: "Swarm cannot track issues - task coordination will be less reliable",
+  "agent-mail": "Multi-agent coordination disabled - file conflicts possible if multiple agents active"
+};
+async function checkTool(tool3) {
+  const cached2 = toolCache.get(tool3);
+  if (cached2) {
+    return cached2;
+  }
+  const checker = toolCheckers[tool3];
+  const status = await checker();
+  toolCache.set(tool3, status);
+  return status;
+}
+async function isToolAvailable(tool3) {
+  const status = await checkTool(tool3);
+  return status.available;
+}
+async function getToolAvailability(tool3) {
+  const status = await checkTool(tool3);
+  return {
+    tool: tool3,
+    status,
+    fallbackBehavior: fallbackBehaviors[tool3]
+  };
+}
+async function checkAllTools() {
+  const tools = [
+    "semantic-memory",
+    "cass",
+    "ubs",
+    "beads",
+    "agent-mail"
+  ];
+  const results = new Map;
+  const checks3 = await Promise.all(tools.map(async (tool3) => ({
+    tool: tool3,
+    availability: await getToolAvailability(tool3)
+  })));
+  for (const { tool: tool3, availability } of checks3) {
+    results.set(tool3, availability);
+  }
+  return results;
+}
+function warnMissingTool(tool3) {
+  if (warningsLogged.has(tool3)) {
+    return;
+  }
+  warningsLogged.add(tool3);
+  const fallback = fallbackBehaviors[tool3];
+  console.warn(`[swarm] ${tool3} not available: ${fallback}`);
+}
+async function requireTool(tool3) {
+  const status = await checkTool(tool3);
+  if (!status.available) {
+    throw new Error(`Required tool '${tool3}' is not available: ${status.error || "unknown error"}`);
+  }
+}
+async function withToolFallback(tool3, action, fallback) {
+  const available = await isToolAvailable(tool3);
+  if (available) {
+    return action();
+  }
+  warnMissingTool(tool3);
+  return fallback();
+}
+async function ifToolAvailable(tool3, action) {
+  const available = await isToolAvailable(tool3);
+  if (available) {
+    return action();
+  }
+  warnMissingTool(tool3);
+  return;
+}
+function resetToolCache() {
+  toolCache.clear();
+  warningsLogged.clear();
+}
+function formatToolAvailability(availability) {
+  const lines = ["Tool Availability:"];
+  for (const [tool3, info] of availability) {
+    const status = info.status.available ? "\u2713" : "\u2717";
+    const version2 = info.status.version ? ` (${info.status.version})` : "";
+    const fallback = info.status.available ? "" : ` \u2192 ${info.fallbackBehavior}`;
+    lines.push(`  ${status} ${tool3}${version2}${fallback}`);
+  }
+  return lines.join(`
+`);
+}
+
 // src/agent-mail.ts
 var AGENT_MAIL_URL = "http://127.0.0.1:8765";
 var DEFAULT_TTL_SECONDS = 3600;
@@ -12913,6 +13149,14 @@ class FileReservationConflictError extends Error {
     this.name = "FileReservationConflictError";
   }
 }
+var agentMailAvailable = null;
+async function checkAgentMailAvailable() {
+  if (agentMailAvailable !== null) {
+    return agentMailAvailable;
+  }
+  agentMailAvailable = await isToolAvailable("agent-mail");
+  return agentMailAvailable;
+}
 async function mcpCall(toolName, args) {
   const response = await fetch(`${AGENT_MAIL_URL}/mcp/`, {
     method: "POST",
@@ -12962,6 +13206,16 @@ var agentmail_init = tool({
     task_description: tool.schema.string().optional().describe("Description of current task")
   },
   async execute(args, ctx) {
+    const available = await checkAgentMailAvailable();
+    if (!available) {
+      warnMissingTool("agent-mail");
+      return JSON.stringify({
+        error: "Agent Mail server not available",
+        available: false,
+        hint: "Start Agent Mail with: agent-mail serve",
+        fallback: "Swarm will continue without multi-agent coordination. File conflicts possible if multiple agents active."
+      }, null, 2);
+    }
     const project = await mcpCall("ensure_project", {
       human_key: args.project_path
     });
@@ -12979,7 +13233,7 @@ var agentmail_init = tool({
       startedAt: new Date().toISOString()
     };
     setState(ctx.sessionID, state);
-    return JSON.stringify({ project, agent }, null, 2);
+    return JSON.stringify({ project, agent, available: true }, null, 2);
   }
 });
 var agentmail_send = tool({
@@ -13670,6 +13924,21 @@ function outcomeToFeedback(outcome, criterion) {
     raw_value: outcome.decayed_value
   };
 }
+class InMemoryFeedbackStorage {
+  events = [];
+  async store(event) {
+    this.events.push(event);
+  }
+  async getByCriterion(criterion) {
+    return this.events.filter((e) => e.criterion === criterion);
+  }
+  async getByBead(beadId) {
+    return this.events.filter((e) => e.bead_id === beadId);
+  }
+  async getAll() {
+    return [...this.events];
+  }
+}
 
 // src/swarm.ts
 var POSITIVE_MARKERS = [
@@ -13762,6 +14031,18 @@ var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subta
 
 {context_section}
 
+## MANDATORY: Beads Issue Tracking
+
+**Every subtask MUST become a bead.** This is non-negotiable.
+
+After decomposition, the coordinator will:
+1. Create an epic bead for the overall task
+2. Create child beads for each subtask
+3. Track progress through bead status updates
+4. Close beads with summaries when complete
+
+Agents MUST update their bead status as they work. No silent progress.
+
 ## Requirements
 
 1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
@@ -13769,6 +14050,7 @@ var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subta
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
 5. **Estimate complexity** - 1 (trivial) to 5 (complex)
+6. **Plan aggressively** - break down more than you think necessary, smaller is better
 
 ## Response Format
 
@@ -13795,10 +14077,12 @@ Respond with a JSON object matching this schema:
 
 ## Guidelines
 
+- **Plan aggressively** - when in doubt, split further. 3 small tasks > 1 medium task
 - **Prefer smaller, focused subtasks** over large complex ones
 - **Include test files** in the same subtask as the code they test
 - **Consider shared types** - if multiple files share types, handle that first
 - **Think about imports** - changes to exported APIs affect downstream files
+- **Explicit > implicit** - spell out what each subtask should do, don't assume
 
 ## File Assignment Examples
 
@@ -13829,19 +14113,49 @@ send a message to the coordinator requesting the change.
 ## Shared Context
 {shared_context}
 
+## MANDATORY: Beads Tracking
+
+You MUST keep your bead updated as you work:
+
+1. **Your bead is already in_progress** - don't change this unless blocked
+2. **If blocked**: \`bd update {bead_id} --status blocked\` and message coordinator
+3. **When done**: Use \`swarm_complete\` - it closes your bead automatically
+4. **Discovered issues**: Create new beads with \`bd create "issue" -t bug\`
+
+**Never work silently.** Your bead status is how the swarm tracks progress.
+
+## MANDATORY: Agent Mail Communication
+
+You MUST communicate with other agents:
+
+1. **Report progress** every significant milestone (not just at the end)
+2. **Ask questions** if requirements are unclear - don't guess
+3. **Announce blockers** immediately - don't spin trying to fix alone
+4. **Coordinate on shared concerns** - if you see something affecting other agents, say so
+
+Use Agent Mail for all communication:
+\`\`\`
+agentmail_send(
+  to: ["coordinator" or specific agent],
+  subject: "Brief subject",
+  body: "Message content",
+  thread_id: "{epic_id}"
+)
+\`\`\`
+
 ## Coordination Protocol
 
 1. **Start**: Your bead is already marked in_progress
-2. **Progress**: Use swarm:progress to report status updates
-3. **Blocked**: If you hit a blocker, report it - don't spin
-4. **Complete**: Use swarm:complete when done - it handles:
+2. **Progress**: Use swarm_progress to report status updates
+3. **Blocked**: Report immediately via Agent Mail - don't spin
+4. **Complete**: Use swarm_complete when done - it handles:
    - Closing your bead with a summary
    - Releasing file reservations
    - Notifying the coordinator
 
 ## Self-Evaluation
 
-Before calling swarm:complete, evaluate your work:
+Before calling swarm_complete, evaluate your work:
 - Type safety: Does it compile without errors?
 - No obvious bugs: Did you handle edge cases?
 - Follows patterns: Does it match existing code style?
@@ -13849,17 +14163,13 @@ Before calling swarm:complete, evaluate your work:
 
 If evaluation fails, fix the issues before completing.
 
-## Communication
+## Planning Your Work
 
-To message other agents or the coordinator:
-\`\`\`
-agent-mail:send(
-  to: ["coordinator_name" or other agent],
-  subject: "Brief subject",
-  body: "Message content",
-  thread_id: "{epic_id}"
-)
-\`\`\`
+Before writing code:
+1. **Read the files** you're assigned to understand current state
+2. **Plan your approach** - what changes, in what order?
+3. **Identify risks** - what could go wrong? What dependencies?
+4. **Communicate your plan** via Agent Mail if non-trivial
 
 Begin work on your subtask now.`;
 var EVALUATION_PROMPT = `Evaluate the work completed for this subtask.
@@ -13934,21 +14244,32 @@ function formatEvaluationPrompt(params) {
   return EVALUATION_PROMPT.replace("{bead_id}", params.bead_id).replace("{subtask_title}", params.subtask_title).replace("{files_touched}", filesList || "(no files recorded)");
 }
 async function queryEpicSubtasks(epicId) {
+  const beadsAvailable = await isToolAvailable("beads");
+  if (!beadsAvailable) {
+    warnMissingTool("beads");
+    return [];
+  }
   const result = await Bun.$`bd list --parent ${epicId} --json`.quiet().nothrow();
   if (result.exitCode !== 0) {
-    throw new SwarmError(`Failed to query subtasks: ${result.stderr.toString()}`, "query_subtasks");
+    console.warn(`[swarm] Failed to query subtasks: ${result.stderr.toString()}`);
+    return [];
   }
   try {
     const parsed = JSON.parse(result.stdout.toString());
     return exports_external.array(BeadSchema).parse(parsed);
   } catch (error45) {
     if (error45 instanceof exports_external.ZodError) {
-      throw new SwarmError(`Invalid bead data: ${error45.message}`, "query_subtasks", error45.issues);
+      console.warn(`[swarm] Invalid bead data: ${error45.message}`);
+      return [];
     }
     throw error45;
   }
 }
 async function querySwarmMessages(projectKey, threadId) {
+  const agentMailAvailable2 = await isToolAvailable("agent-mail");
+  if (!agentMailAvailable2) {
+    return 0;
+  }
   try {
     const summary = await mcpCall("summarize_thread", {
       project_key: projectKey,
@@ -13977,11 +14298,13 @@ ${progress.blockers.map((b) => `- ${b}`).join(`
 `);
 }
 async function queryCassHistory(task, limit = 3) {
+  const cassAvailable = await isToolAvailable("cass");
+  if (!cassAvailable) {
+    warnMissingTool("cass");
+    return null;
+  }
   try {
     const result = await Bun.$`cass search ${task} --limit ${limit} --json`.quiet().nothrow();
-    if (result.exitCode === 127) {
-      return null;
-    }
     if (result.exitCode !== 0) {
       return null;
     }
@@ -14241,11 +14564,13 @@ async function runUbsScan(files) {
   if (files.length === 0) {
     return null;
   }
+  const ubsAvailable = await isToolAvailable("ubs");
+  if (!ubsAvailable) {
+    warnMissingTool("ubs");
+    return null;
+  }
   try {
     const result = await Bun.$`ubs scan ${files.join(" ")} --json`.quiet().nothrow();
-    if (result.exitCode === 127) {
-      return null;
-    }
     const output = result.stdout.toString();
     if (!output.trim()) {
       return {
@@ -14476,7 +14801,56 @@ var swarm_evaluation_prompt = tool({
     }, null, 2);
   }
 });
+var swarm_init = tool({
+  description: "Initialize swarm session and check tool availability. Call at swarm start to see what features are available.",
+  args: {
+    project_path: tool.schema.string().optional().describe("Project path (for Agent Mail init)")
+  },
+  async execute(args) {
+    const availability = await checkAllTools();
+    const report = formatToolAvailability(availability);
+    const beadsAvailable = availability.get("beads")?.status.available ?? false;
+    const agentMailAvailable2 = availability.get("agent-mail")?.status.available ?? false;
+    const warnings = [];
+    const degradedFeatures = [];
+    if (!beadsAvailable) {
+      warnings.push("\u26A0\uFE0F  beads (bd) not available - issue tracking disabled, swarm coordination will be limited");
+      degradedFeatures.push("issue tracking", "progress persistence");
+    }
+    if (!agentMailAvailable2) {
+      warnings.push("\u26A0\uFE0F  agent-mail not available - multi-agent communication disabled");
+      degradedFeatures.push("agent communication", "file reservations");
+    }
+    if (!availability.get("cass")?.status.available) {
+      degradedFeatures.push("historical context from past sessions");
+    }
+    if (!availability.get("ubs")?.status.available) {
+      degradedFeatures.push("pre-completion bug scanning");
+    }
+    if (!availability.get("semantic-memory")?.status.available) {
+      degradedFeatures.push("persistent learning (using in-memory fallback)");
+    }
+    return JSON.stringify({
+      ready: true,
+      tool_availability: Object.fromEntries(Array.from(availability.entries()).map(([k, v]) => [
+        k,
+        {
+          available: v.status.available,
+          fallback: v.status.available ? null : v.fallbackBehavior
+        }
+      ])),
+      warnings: warnings.length > 0 ? warnings : undefined,
+      degraded_features: degradedFeatures.length > 0 ? degradedFeatures : undefined,
+      recommendations: {
+        beads: beadsAvailable ? "\u2713 Use beads for all task tracking" : "Install beads: npm i -g @joelhooks/beads",
+        agent_mail: agentMailAvailable2 ? "\u2713 Use Agent Mail for coordination" : "Start Agent Mail: agent-mail serve"
+      },
+      report
+    }, null, 2);
+  }
+});
 var swarmTools = {
+  swarm_init,
   swarm_decompose,
   swarm_validate_decomposition,
   swarm_status,
@@ -14486,6 +14860,394 @@ var swarmTools = {
   swarm_subtask_prompt,
   swarm_evaluation_prompt
 };
+// src/anti-patterns.ts
+var PatternKindSchema = exports_external.enum(["pattern", "anti_pattern"]);
+var DecompositionPatternSchema = exports_external.object({
+  id: exports_external.string(),
+  content: exports_external.string(),
+  kind: PatternKindSchema,
+  is_negative: exports_external.boolean(),
+  success_count: exports_external.number().int().min(0).default(0),
+  failure_count: exports_external.number().int().min(0).default(0),
+  created_at: exports_external.string(),
+  updated_at: exports_external.string(),
+  reason: exports_external.string().optional(),
+  tags: exports_external.array(exports_external.string()).default([]),
+  example_beads: exports_external.array(exports_external.string()).default([])
+});
+var PatternInversionResultSchema = exports_external.object({
+  original: DecompositionPatternSchema,
+  inverted: DecompositionPatternSchema,
+  reason: exports_external.string()
+});
+class InMemoryPatternStorage {
+  patterns = new Map;
+  async store(pattern) {
+    this.patterns.set(pattern.id, pattern);
+  }
+  async get(id) {
+    return this.patterns.get(id) ?? null;
+  }
+  async getAll() {
+    return Array.from(this.patterns.values());
+  }
+  async getAntiPatterns() {
+    return Array.from(this.patterns.values()).filter((p) => p.kind === "anti_pattern");
+  }
+  async getByTag(tag) {
+    return Array.from(this.patterns.values()).filter((p) => p.tags.includes(tag));
+  }
+  async findByContent(content) {
+    const lower = content.toLowerCase();
+    return Array.from(this.patterns.values()).filter((p) => p.content.toLowerCase().includes(lower));
+  }
+}
+
+// src/pattern-maturity.ts
+var MaturityStateSchema = exports_external.enum([
+  "candidate",
+  "established",
+  "proven",
+  "deprecated"
+]);
+var PatternMaturitySchema = exports_external.object({
+  pattern_id: exports_external.string(),
+  state: MaturityStateSchema,
+  helpful_count: exports_external.number().int().min(0),
+  harmful_count: exports_external.number().int().min(0),
+  last_validated: exports_external.string(),
+  promoted_at: exports_external.string().optional(),
+  deprecated_at: exports_external.string().optional()
+});
+var MaturityFeedbackSchema = exports_external.object({
+  pattern_id: exports_external.string(),
+  type: exports_external.enum(["helpful", "harmful"]),
+  timestamp: exports_external.string(),
+  weight: exports_external.number().min(0).max(1).default(1)
+});
+class InMemoryMaturityStorage {
+  maturities = new Map;
+  feedback = [];
+  async store(maturity) {
+    this.maturities.set(maturity.pattern_id, maturity);
+  }
+  async get(patternId) {
+    return this.maturities.get(patternId) ?? null;
+  }
+  async getAll() {
+    return Array.from(this.maturities.values());
+  }
+  async getByState(state) {
+    return Array.from(this.maturities.values()).filter((m) => m.state === state);
+  }
+  async storeFeedback(feedback) {
+    this.feedback.push(feedback);
+  }
+  async getFeedback(patternId) {
+    return this.feedback.filter((f) => f.pattern_id === patternId);
+  }
+}
+
+// src/storage.ts
+var cachedCommand = null;
+async function resolveSemanticMemoryCommand() {
+  if (cachedCommand)
+    return cachedCommand;
+  const nativeResult = await Bun.$`which semantic-memory`.quiet().nothrow();
+  if (nativeResult.exitCode === 0) {
+    cachedCommand = ["semantic-memory"];
+    return cachedCommand;
+  }
+  cachedCommand = ["bunx", "semantic-memory"];
+  return cachedCommand;
+}
+async function execSemanticMemory(args) {
+  const cmd = await resolveSemanticMemoryCommand();
+  const fullCmd = [...cmd, ...args];
+  const proc = Bun.spawn(fullCmd, {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdout = Buffer.from(await new Response(proc.stdout).arrayBuffer());
+  const stderr = Buffer.from(await new Response(proc.stderr).arrayBuffer());
+  const exitCode = await proc.exited;
+  return { exitCode, stdout, stderr };
+}
+var DEFAULT_STORAGE_CONFIG = {
+  backend: "semantic-memory",
+  collections: {
+    feedback: "swarm-feedback",
+    patterns: "swarm-patterns",
+    maturity: "swarm-maturity"
+  },
+  useSemanticSearch: true
+};
+
+class SemanticMemoryStorage {
+  config;
+  constructor(config2 = {}) {
+    this.config = { ...DEFAULT_STORAGE_CONFIG, ...config2 };
+  }
+  async store(collection, data, metadata) {
+    const content = typeof data === "string" ? data : JSON.stringify(data);
+    const args = ["store", content, "--collection", collection];
+    if (metadata) {
+      args.push("--metadata", JSON.stringify(metadata));
+    }
+    await execSemanticMemory(args);
+  }
+  async find(collection, query, limit = 10, useFts = false) {
+    const args = [
+      "find",
+      query,
+      "--collection",
+      collection,
+      "--limit",
+      String(limit),
+      "--json"
+    ];
+    if (useFts) {
+      args.push("--fts");
+    }
+    const result = await execSemanticMemory(args);
+    if (result.exitCode !== 0) {
+      return [];
+    }
+    try {
+      const output = result.stdout.toString().trim();
+      if (!output)
+        return [];
+      const parsed = JSON.parse(output);
+      const results = Array.isArray(parsed) ? parsed : parsed.results || [];
+      return results.map((r) => {
+        const content = r.content || r.information || "";
+        try {
+          return JSON.parse(content);
+        } catch {
+          return content;
+        }
+      });
+    } catch {
+      return [];
+    }
+  }
+  async list(collection) {
+    const result = await execSemanticMemory([
+      "list",
+      "--collection",
+      collection,
+      "--json"
+    ]);
+    if (result.exitCode !== 0) {
+      return [];
+    }
+    try {
+      const output = result.stdout.toString().trim();
+      if (!output)
+        return [];
+      const parsed = JSON.parse(output);
+      const items = Array.isArray(parsed) ? parsed : parsed.items || [];
+      return items.map((item) => {
+        const content = item.content || item.information || "";
+        try {
+          return JSON.parse(content);
+        } catch {
+          return content;
+        }
+      });
+    } catch {
+      return [];
+    }
+  }
+  async storeFeedback(event) {
+    await this.store(this.config.collections.feedback, event, {
+      criterion: event.criterion,
+      type: event.type,
+      bead_id: event.bead_id || "",
+      timestamp: event.timestamp
+    });
+  }
+  async getFeedbackByCriterion(criterion) {
+    return this.find(this.config.collections.feedback, criterion, 100, true);
+  }
+  async getFeedbackByBead(beadId) {
+    return this.find(this.config.collections.feedback, beadId, 100, true);
+  }
+  async getAllFeedback() {
+    return this.list(this.config.collections.feedback);
+  }
+  async findSimilarFeedback(query, limit = 10) {
+    return this.find(this.config.collections.feedback, query, limit, !this.config.useSemanticSearch);
+  }
+  async storePattern(pattern) {
+    await this.store(this.config.collections.patterns, pattern, {
+      id: pattern.id,
+      kind: pattern.kind,
+      is_negative: pattern.is_negative,
+      tags: pattern.tags.join(",")
+    });
+  }
+  async getPattern(id) {
+    const all = await this.list(this.config.collections.patterns);
+    return all.find((p) => p.id === id) || null;
+  }
+  async getAllPatterns() {
+    return this.list(this.config.collections.patterns);
+  }
+  async getAntiPatterns() {
+    const all = await this.getAllPatterns();
+    return all.filter((p) => p.kind === "anti_pattern");
+  }
+  async getPatternsByTag(tag) {
+    const results = await this.find(this.config.collections.patterns, tag, 100, true);
+    return results.filter((p) => p.tags.includes(tag));
+  }
+  async findSimilarPatterns(query, limit = 10) {
+    return this.find(this.config.collections.patterns, query, limit, !this.config.useSemanticSearch);
+  }
+  async storeMaturity(maturity) {
+    await this.store(this.config.collections.maturity, maturity, {
+      pattern_id: maturity.pattern_id,
+      state: maturity.state
+    });
+  }
+  async getMaturity(patternId) {
+    const all = await this.list(this.config.collections.maturity);
+    return all.find((m) => m.pattern_id === patternId) || null;
+  }
+  async getAllMaturity() {
+    return this.list(this.config.collections.maturity);
+  }
+  async getMaturityByState(state) {
+    const all = await this.getAllMaturity();
+    return all.filter((m) => m.state === state);
+  }
+  async storeMaturityFeedback(feedback) {
+    await this.store(this.config.collections.maturity + "-feedback", feedback, {
+      pattern_id: feedback.pattern_id,
+      type: feedback.type,
+      timestamp: feedback.timestamp
+    });
+  }
+  async getMaturityFeedback(patternId) {
+    const all = await this.list(this.config.collections.maturity + "-feedback");
+    return all.filter((f) => f.pattern_id === patternId);
+  }
+  async close() {}
+}
+
+class InMemoryStorage {
+  feedback;
+  patterns;
+  maturity;
+  constructor() {
+    this.feedback = new InMemoryFeedbackStorage;
+    this.patterns = new InMemoryPatternStorage;
+    this.maturity = new InMemoryMaturityStorage;
+  }
+  async storeFeedback(event) {
+    return this.feedback.store(event);
+  }
+  async getFeedbackByCriterion(criterion) {
+    return this.feedback.getByCriterion(criterion);
+  }
+  async getFeedbackByBead(beadId) {
+    return this.feedback.getByBead(beadId);
+  }
+  async getAllFeedback() {
+    return this.feedback.getAll();
+  }
+  async findSimilarFeedback(query, limit = 10) {
+    const all = await this.feedback.getAll();
+    const lowerQuery = query.toLowerCase();
+    const filtered = all.filter((event) => event.criterion.toLowerCase().includes(lowerQuery) || event.bead_id && event.bead_id.toLowerCase().includes(lowerQuery) || event.context && event.context.toLowerCase().includes(lowerQuery));
+    return filtered.slice(0, limit);
+  }
+  async storePattern(pattern) {
+    return this.patterns.store(pattern);
+  }
+  async getPattern(id) {
+    return this.patterns.get(id);
+  }
+  async getAllPatterns() {
+    return this.patterns.getAll();
+  }
+  async getAntiPatterns() {
+    return this.patterns.getAntiPatterns();
+  }
+  async getPatternsByTag(tag) {
+    return this.patterns.getByTag(tag);
+  }
+  async findSimilarPatterns(query, limit = 10) {
+    const results = await this.patterns.findByContent(query);
+    return results.slice(0, limit);
+  }
+  async storeMaturity(maturity) {
+    return this.maturity.store(maturity);
+  }
+  async getMaturity(patternId) {
+    return this.maturity.get(patternId);
+  }
+  async getAllMaturity() {
+    return this.maturity.getAll();
+  }
+  async getMaturityByState(state) {
+    return this.maturity.getByState(state);
+  }
+  async storeMaturityFeedback(feedback) {
+    return this.maturity.storeFeedback(feedback);
+  }
+  async getMaturityFeedback(patternId) {
+    return this.maturity.getFeedback(patternId);
+  }
+  async close() {}
+}
+function createStorage(config2 = {}) {
+  const fullConfig = { ...DEFAULT_STORAGE_CONFIG, ...config2 };
+  switch (fullConfig.backend) {
+    case "semantic-memory":
+      return new SemanticMemoryStorage(fullConfig);
+    case "memory":
+      return new InMemoryStorage;
+    default:
+      throw new Error(`Unknown storage backend: ${fullConfig.backend}`);
+  }
+}
+async function isSemanticMemoryAvailable() {
+  try {
+    const result = await execSemanticMemory(["stats"]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function createStorageWithFallback(config2 = {}) {
+  if (config2.backend === "memory") {
+    return new InMemoryStorage;
+  }
+  const available = await isSemanticMemoryAvailable();
+  if (available) {
+    return new SemanticMemoryStorage(config2);
+  }
+  console.warn("semantic-memory not available, falling back to in-memory storage");
+  return new InMemoryStorage;
+}
+var globalStorage = null;
+async function getStorage() {
+  if (!globalStorage) {
+    globalStorage = await createStorageWithFallback();
+  }
+  return globalStorage;
+}
+function setStorage(storage) {
+  globalStorage = storage;
+}
+async function resetStorage() {
+  if (globalStorage) {
+    await globalStorage.close();
+    globalStorage = null;
+  }
+}
 
 // src/index.ts
 var SwarmPlugin = async (input) => {
@@ -14567,14 +15329,30 @@ var SwarmPlugin = async (input) => {
 };
 var src_default = SwarmPlugin;
 export {
+  withToolFallback,
+  warnMissingTool,
   swarmTools,
   structuredTools,
+  setStorage,
+  resetToolCache,
+  resetStorage,
+  requireTool,
+  isToolAvailable,
+  isSemanticMemoryAvailable,
+  ifToolAvailable,
+  getToolAvailability,
+  getStorage,
   getSchemaByName,
   formatZodErrors,
+  formatToolAvailability,
   formatSubtaskPrompt,
   formatEvaluationPrompt,
   extractJsonFromText,
   src_default as default,
+  createStorageWithFallback,
+  createStorage,
+  checkTool,
+  checkAllTools,
   beads_update,
   beads_sync,
   beads_start,
@@ -14598,6 +15376,8 @@ export {
   SubtaskSpecSchema,
   SubtaskDependencySchema,
   SpawnedAgentSchema,
+  SemanticMemoryStorage,
+  InMemoryStorage,
   FileReservationConflictError,
   EvaluationSchema,
   EvaluationRequestSchema,
@@ -14608,6 +15388,7 @@ export {
   DecompositionError,
   DecomposedSubtaskSchema,
   DecomposeArgsSchema,
+  DEFAULT_STORAGE_CONFIG,
   DEFAULT_CRITERIA,
   CriterionEvaluationSchema,
   BeadValidationError,