opencode-swarm-plugin 0.53.0 → 0.54.0

package/dist/swarm-prompts.js

@@ -12693,6 +12693,7 @@ var init_dist = __esm(() => {
 var exports_learning = {};
 __export(exports_learning, {
   shouldDeprecateCriterion: () => shouldDeprecateCriterion,
+  scoreOutcome: () => scoreOutcome,
   scoreImplicitFeedback: () => scoreImplicitFeedback,
   outcomeToFeedback: () => outcomeToFeedback,
   learningSchemas: () => learningSchemas,
@@ -12800,6 +12801,14 @@ function scoreImplicitFeedback(signals, config2 = DEFAULT_LEARNING_CONFIG) {
     reasoning
   };
 }
+function scoreOutcome(signals, config2 = DEFAULT_LEARNING_CONFIG) {
+  const scored = scoreImplicitFeedback(signals, config2);
+  return {
+    type: scored.type,
+    score: scored.decayed_value,
+    reasoning: scored.reasoning
+  };
+}
 function outcomeToFeedback(outcome, criterion) {
   return {
     id: `${outcome.signals.bead_id}-${criterion}-${Date.now()}`,
@@ -18207,6 +18216,902 @@ echo "Project directory: $1"
   };
 });
 
+// src/anti-patterns.ts
+var exports_anti_patterns = {};
+__export(exports_anti_patterns, {
+  shouldInvertPattern: () => shouldInvertPattern,
+  recordPatternObservation: () => recordPatternObservation,
+  invertToAntiPattern: () => invertToAntiPattern,
+  formatSuccessfulPatternsForPrompt: () => formatSuccessfulPatternsForPrompt,
+  formatAntiPatternsForPrompt: () => formatAntiPatternsForPrompt,
+  extractPatternsFromDescription: () => extractPatternsFromDescription,
+  createPattern: () => createPattern,
+  antiPatternSchemas: () => antiPatternSchemas,
+  PatternKindSchema: () => PatternKindSchema,
+  PatternInversionResultSchema: () => PatternInversionResultSchema,
+  InMemoryPatternStorage: () => InMemoryPatternStorage,
+  DecompositionPatternSchema: () => DecompositionPatternSchema,
+  DEFAULT_ANTI_PATTERN_CONFIG: () => DEFAULT_ANTI_PATTERN_CONFIG
+});
+function shouldInvertPattern(pattern, config2 = DEFAULT_ANTI_PATTERN_CONFIG) {
+  if (pattern.kind === "anti_pattern") {
+    return false;
+  }
+  const total = pattern.success_count + pattern.failure_count;
+  if (total < config2.minObservations) {
+    return false;
+  }
+  const failureRatio = pattern.failure_count / total;
+  return failureRatio >= config2.failureRatioThreshold;
+}
+function invertToAntiPattern(pattern, reason, config2 = DEFAULT_ANTI_PATTERN_CONFIG) {
+  const cleaned = pattern.content.replace(/^AVOID:\s*/i, "").replace(/^DO NOT:\s*/i, "").replace(/^NEVER:\s*/i, "");
+  const inverted = {
+    ...pattern,
+    id: `anti-${pattern.id}`,
+    content: `${config2.antiPatternPrefix}${cleaned}. ${reason}`,
+    kind: "anti_pattern",
+    is_negative: true,
+    reason,
+    updated_at: new Date().toISOString()
+  };
+  return {
+    original: pattern,
+    inverted,
+    reason
+  };
+}
+function recordPatternObservation(pattern, success2, beadId, config2 = DEFAULT_ANTI_PATTERN_CONFIG) {
+  const updated = {
+    ...pattern,
+    success_count: success2 ? pattern.success_count + 1 : pattern.success_count,
+    failure_count: success2 ? pattern.failure_count : pattern.failure_count + 1,
+    updated_at: new Date().toISOString(),
+    example_beads: beadId ? [...pattern.example_beads.slice(-(MAX_EXAMPLE_BEADS - 1)), beadId] : pattern.example_beads
+  };
+  if (shouldInvertPattern(updated, config2)) {
+    const total = updated.success_count + updated.failure_count;
+    const failureRatio = updated.failure_count / total;
+    const reason = `Failed ${updated.failure_count}/${total} times (${Math.round(failureRatio * 100)}% failure rate)`;
+    return {
+      pattern: updated,
+      inversion: invertToAntiPattern(updated, reason, config2)
+    };
+  }
+  return { pattern: updated };
+}
+function extractPatternsFromDescription(description) {
+  const patterns = [];
+  const strategyPatterns = [
+    {
+      regex: /split(?:ting)?\s+by\s+file\s+type/i,
+      pattern: "Split by file type"
+    },
+    {
+      regex: /split(?:ting)?\s+by\s+component/i,
+      pattern: "Split by component"
+    },
+    {
+      regex: /split(?:ting)?\s+by\s+layer/i,
+      pattern: "Split by layer (UI/logic/data)"
+    },
+    { regex: /split(?:ting)?\s+by\s+feature/i, pattern: "Split by feature" },
+    {
+      regex: /one\s+file\s+per\s+(?:sub)?task/i,
+      pattern: "One file per subtask"
+    },
+    { regex: /shared\s+types?\s+first/i, pattern: "Handle shared types first" },
+    { regex: /api\s+(?:routes?)?\s+separate/i, pattern: "Separate API routes" },
+    {
+      regex: /tests?\s+(?:with|alongside)\s+(?:code|implementation)/i,
+      pattern: "Tests alongside implementation"
+    },
+    {
+      regex: /tests?\s+(?:in\s+)?separate\s+(?:sub)?task/i,
+      pattern: "Tests in separate subtask"
+    },
+    {
+      regex: /parallel(?:ize)?\s+(?:all|everything)/i,
+      pattern: "Maximize parallelization"
+    },
+    {
+      regex: /sequential\s+(?:order|execution)/i,
+      pattern: "Sequential execution order"
+    },
+    {
+      regex: /dependency\s+(?:chain|order)/i,
+      pattern: "Respect dependency chain"
+    }
+  ];
+  for (const { regex, pattern } of strategyPatterns) {
+    if (regex.test(description)) {
+      patterns.push(pattern);
+    }
+  }
+  return patterns;
+}
+function createPattern(content, tags = []) {
+  const now = new Date().toISOString();
+  return {
+    id: `pattern-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    content,
+    kind: "pattern",
+    is_negative: false,
+    success_count: 0,
+    failure_count: 0,
+    created_at: now,
+    updated_at: now,
+    tags,
+    example_beads: []
+  };
+}
+function formatAntiPatternsForPrompt(patterns) {
+  const antiPatterns = patterns.filter((p) => p.kind === "anti_pattern");
+  if (antiPatterns.length === 0) {
+    return "";
+  }
+  const lines = [
+    "## Anti-Patterns to Avoid",
+    "",
+    "Based on past failures, avoid these decomposition strategies:",
+    "",
+    ...antiPatterns.map((p) => `- ${p.content}`),
+    ""
+  ];
+  return lines.join(`
+`);
+}
+function formatSuccessfulPatternsForPrompt(patterns, minSuccessRate = 0.7) {
+  const successful = patterns.filter((p) => {
+    if (p.kind === "anti_pattern")
+      return false;
+    const total = p.success_count + p.failure_count;
+    if (total < 2)
+      return false;
+    return p.success_count / total >= minSuccessRate;
+  });
+  if (successful.length === 0) {
+    return "";
+  }
+  const lines = [
+    "## Successful Patterns",
+    "",
+    "These decomposition strategies have worked well in the past:",
+    "",
+    ...successful.map((p) => {
+      const total = p.success_count + p.failure_count;
+      const rate = Math.round(p.success_count / total * 100);
+      return `- ${p.content} (${rate}% success rate)`;
+    }),
+    ""
+  ];
+  return lines.join(`
+`);
+}
+
+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));
+  }
+}
+var PatternKindSchema, DecompositionPatternSchema, PatternInversionResultSchema, MAX_EXAMPLE_BEADS = 10, DEFAULT_ANTI_PATTERN_CONFIG, antiPatternSchemas;
+var init_anti_patterns = __esm(() => {
+  init_zod();
+  PatternKindSchema = exports_external.enum(["pattern", "anti_pattern"]);
+  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([])
+  });
+  PatternInversionResultSchema = exports_external.object({
+    original: DecompositionPatternSchema,
+    inverted: DecompositionPatternSchema,
+    reason: exports_external.string()
+  });
+  DEFAULT_ANTI_PATTERN_CONFIG = {
+    minObservations: 3,
+    failureRatioThreshold: 0.6,
+    antiPatternPrefix: "AVOID: "
+  };
+  antiPatternSchemas = {
+    PatternKindSchema,
+    DecompositionPatternSchema,
+    PatternInversionResultSchema
+  };
+});
+
+// src/pattern-maturity.ts
+var exports_pattern_maturity = {};
+__export(exports_pattern_maturity, {
+  updatePatternMaturity: () => updatePatternMaturity,
+  promotePattern: () => promotePattern,
+  maturitySchemas: () => maturitySchemas,
+  getMaturityMultiplier: () => getMaturityMultiplier,
+  formatPatternsWithMaturityForPrompt: () => formatPatternsWithMaturityForPrompt,
+  formatMaturityForPrompt: () => formatMaturityForPrompt,
+  deprecatePattern: () => deprecatePattern,
+  createPatternMaturity: () => createPatternMaturity,
+  calculateMaturityState: () => calculateMaturityState,
+  calculateDecayedCounts: () => calculateDecayedCounts,
+  PatternMaturitySchema: () => PatternMaturitySchema,
+  MaturityStateSchema: () => MaturityStateSchema,
+  MaturityFeedbackSchema: () => MaturityFeedbackSchema,
+  InMemoryMaturityStorage: () => InMemoryMaturityStorage,
+  DEFAULT_MATURITY_CONFIG: () => DEFAULT_MATURITY_CONFIG
+});
+function calculateDecayedCounts(feedbackEvents, config2 = DEFAULT_MATURITY_CONFIG, now = new Date) {
+  let decayedHelpful = 0;
+  let decayedHarmful = 0;
+  for (const event of feedbackEvents) {
+    const decay = calculateDecayedValue(event.timestamp, now, config2.halfLifeDays);
+    const value = event.weight * decay;
+    if (event.type === "helpful") {
+      decayedHelpful += value;
+    } else {
+      decayedHarmful += value;
+    }
+  }
+  return { decayedHelpful, decayedHarmful };
+}
+function calculateMaturityState(feedbackEvents, config2 = DEFAULT_MATURITY_CONFIG, now = new Date) {
+  const { decayedHelpful, decayedHarmful } = calculateDecayedCounts(feedbackEvents, config2, now);
+  const total = decayedHelpful + decayedHarmful;
+  const safeTotal = total > FLOAT_EPSILON ? total : 0;
+  const harmfulRatio = safeTotal > 0 ? decayedHarmful / safeTotal : 0;
+  if (harmfulRatio > config2.deprecationThreshold && safeTotal >= config2.minFeedback - FLOAT_EPSILON) {
+    return "deprecated";
+  }
+  if (safeTotal < config2.minFeedback - FLOAT_EPSILON) {
+    return "candidate";
+  }
+  if (decayedHelpful >= config2.minHelpful - FLOAT_EPSILON && harmfulRatio < config2.maxHarmful) {
+    return "proven";
+  }
+  return "established";
+}
+function createPatternMaturity(patternId) {
+  return {
+    pattern_id: patternId,
+    state: "candidate",
+    helpful_count: 0,
+    harmful_count: 0,
+    last_validated: new Date().toISOString()
+  };
+}
+function updatePatternMaturity(maturity, feedbackEvents, config2 = DEFAULT_MATURITY_CONFIG) {
+  const now = new Date;
+  const newState = calculateMaturityState(feedbackEvents, config2, now);
+  const helpfulCount = feedbackEvents.filter((e) => e.type === "helpful").length;
+  const harmfulCount = feedbackEvents.filter((e) => e.type === "harmful").length;
+  const updated = {
+    ...maturity,
+    state: newState,
+    helpful_count: helpfulCount,
+    harmful_count: harmfulCount,
+    last_validated: now.toISOString()
+  };
+  if (newState === "proven" && maturity.state !== "proven") {
+    updated.promoted_at = now.toISOString();
+  }
+  if (newState === "deprecated" && maturity.state !== "deprecated") {
+    updated.deprecated_at = now.toISOString();
+  }
+  return updated;
+}
+function promotePattern(maturity) {
+  if (maturity.state === "deprecated") {
+    throw new Error("Cannot promote a deprecated pattern");
+  }
+  if (maturity.state === "proven") {
+    console.warn(`[PatternMaturity] Pattern already proven: ${maturity.pattern_id}`);
+    return maturity;
+  }
+  if (maturity.state === "candidate" && maturity.helpful_count < 3) {
+    console.warn(`[PatternMaturity] Promoting candidate with insufficient data: ${maturity.pattern_id} (${maturity.helpful_count} helpful observations)`);
+  }
+  const now = new Date().toISOString();
+  return {
+    ...maturity,
+    state: "proven",
+    promoted_at: now,
+    last_validated: now
+  };
+}
+function deprecatePattern(maturity, _reason) {
+  if (maturity.state === "deprecated") {
+    return maturity;
+  }
+  const now = new Date().toISOString();
+  return {
+    ...maturity,
+    state: "deprecated",
+    deprecated_at: now,
+    last_validated: now
+  };
+}
+function getMaturityMultiplier(state) {
+  const multipliers = {
+    candidate: 0.5,
+    established: 1,
+    proven: 1.5,
+    deprecated: 0
+  };
+  return multipliers[state];
+}
+function formatMaturityForPrompt(maturity) {
+  const total = maturity.helpful_count + maturity.harmful_count;
+  if (total < 3) {
+    return `[LIMITED DATA - ${total} observation${total !== 1 ? "s" : ""}]`;
+  }
+  const harmfulRatio = total > 0 ? Math.round(maturity.harmful_count / total * 100) : 0;
+  const helpfulRatio = total > 0 ? Math.round(maturity.helpful_count / total * 100) : 0;
+  switch (maturity.state) {
+    case "candidate":
+      return `[CANDIDATE - ${total} observations, needs more data]`;
+    case "established":
+      return `[ESTABLISHED - ${helpfulRatio}% helpful, ${harmfulRatio}% harmful from ${total} observations]`;
+    case "proven":
+      return `[PROVEN - ${helpfulRatio}% helpful from ${total} observations]`;
+    case "deprecated":
+      return `[DEPRECATED - ${harmfulRatio}% harmful, avoid using]`;
+  }
+}
+function formatPatternsWithMaturityForPrompt(patterns) {
+  const proven = [];
+  const established = [];
+  const candidates = [];
+  const deprecated = [];
+  for (const [content, maturity] of patterns) {
+    const formatted = `- ${content} ${formatMaturityForPrompt(maturity)}`;
+    switch (maturity.state) {
+      case "proven":
+        proven.push(formatted);
+        break;
+      case "established":
+        established.push(formatted);
+        break;
+      case "candidate":
+        candidates.push(formatted);
+        break;
+      case "deprecated":
+        deprecated.push(formatted);
+        break;
+    }
+  }
+  const sections = [];
+  if (proven.length > 0) {
+    sections.push(`## Proven Patterns
+
+These patterns consistently work well:
+
+` + proven.join(`
+`));
+  }
+  if (established.length > 0) {
+    sections.push(`## Established Patterns
+
+These patterns have track records:
+
+` + established.join(`
+`));
+  }
+  if (candidates.length > 0) {
+    sections.push(`## Candidate Patterns
+
+These patterns need more validation:
+
+` + candidates.join(`
+`));
+  }
+  if (deprecated.length > 0) {
+    sections.push(`## Deprecated Patterns
+
+AVOID these patterns - they have poor track records:
+
+` + deprecated.join(`
+`));
+  }
+  return sections.join(`
+
+`);
+}
+
+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);
+  }
+}
+var FLOAT_EPSILON = 0.01, MaturityStateSchema, PatternMaturitySchema, MaturityFeedbackSchema, DEFAULT_MATURITY_CONFIG, maturitySchemas;
+var init_pattern_maturity = __esm(() => {
+  init_zod();
+  init_learning();
+  MaturityStateSchema = exports_external.enum([
+    "candidate",
+    "established",
+    "proven",
+    "deprecated"
+  ]);
+  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()
+  });
+  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)
+  });
+  DEFAULT_MATURITY_CONFIG = {
+    minFeedback: 3,
+    minHelpful: 5,
+    maxHarmful: 0.15,
+    deprecationThreshold: 0.3,
+    halfLifeDays: 90
+  };
+  maturitySchemas = {
+    MaturityStateSchema,
+    PatternMaturitySchema,
+    MaturityFeedbackSchema
+  };
+});
+
+// src/storage.ts
+var exports_storage = {};
+__export(exports_storage, {
+  setStorage: () => setStorage,
+  resetStorage: () => resetStorage,
+  resetSessionStats: () => resetSessionStats,
+  resetCommandCache: () => resetCommandCache,
+  isSemanticMemoryAvailable: () => isSemanticMemoryAvailable,
+  getTestCollectionName: () => getTestCollectionName,
+  getStorage: () => getStorage,
+  getSessionStats: () => getSessionStats,
+  getResolvedCommand: () => getResolvedCommand,
+  getDefaultStorageConfig: () => getDefaultStorageConfig,
+  createStorageWithFallback: () => createStorageWithFallback,
+  createStorage: () => createStorage,
+  SemanticMemoryStorage: () => SemanticMemoryStorage,
+  InMemoryStorage: () => InMemoryStorage,
+  DEFAULT_STORAGE_CONFIG: () => DEFAULT_STORAGE_CONFIG
+});
+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) {
+  try {
+    const cmd = await resolveSemanticMemoryCommand();
+    const fullCmd = [...cmd, ...args];
+    const proc = Bun.spawn(fullCmd, {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    try {
+      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 };
+    } finally {
+      proc.kill();
+    }
+  } catch (error45) {
+    const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+    return {
+      exitCode: 1,
+      stdout: Buffer.from(""),
+      stderr: Buffer.from(`Error executing semantic-memory: ${errorMessage}`)
+    };
+  }
+}
+function resetCommandCache() {
+  cachedCommand = null;
+}
+function getTestCollectionName() {
+  return `test-${Date.now()}`;
+}
+function getCollectionNames() {
+  const base = {
+    feedback: "swarm-feedback",
+    patterns: "swarm-patterns",
+    maturity: "swarm-maturity"
+  };
+  const testSuffix = process.env.TEST_SEMANTIC_MEMORY_COLLECTION;
+  if (testSuffix) {
+    return {
+      feedback: `${base.feedback}-${testSuffix}`,
+      patterns: `${base.patterns}-${testSuffix}`,
+      maturity: `${base.maturity}-${testSuffix}`
+    };
+  }
+  if (process.env.TEST_MEMORY_COLLECTIONS === "true") {
+    return {
+      feedback: `${base.feedback}-test`,
+      patterns: `${base.patterns}-test`,
+      maturity: `${base.maturity}-test`
+    };
+  }
+  return base;
+}
+function getDefaultStorageConfig() {
+  return {
+    backend: "semantic-memory",
+    collections: getCollectionNames(),
+    useSemanticSearch: true
+  };
+}
+function resetSessionStats() {
+  sessionStats = {
+    storesCount: 0,
+    queriesCount: 0,
+    sessionStart: Date.now(),
+    lastAlertCheck: Date.now()
+  };
+}
+function getSessionStats() {
+  return { ...sessionStats };
+}
+
+class SemanticMemoryStorage {
+  config;
+  constructor(config2 = {}) {
+    this.config = { ...getDefaultStorageConfig(), ...config2 };
+  }
+  async checkLowUsageAlert() {
+    const TEN_MINUTES = 10 * 60 * 1000;
+    const now = Date.now();
+    const sessionDuration = now - sessionStats.sessionStart;
+    const timeSinceLastAlert = now - sessionStats.lastAlertCheck;
+    if (sessionDuration >= TEN_MINUTES && sessionStats.storesCount < 1 && timeSinceLastAlert >= TEN_MINUTES) {
+      console.warn(`[storage] LOW USAGE ALERT: ${sessionStats.storesCount} stores after ${Math.floor(sessionDuration / 60000)} minutes`);
+      sessionStats.lastAlertCheck = now;
+    }
+  }
+  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));
+    }
+    sessionStats.storesCount++;
+    const result = await execSemanticMemory(args);
+    if (result.exitCode !== 0) {
+      console.warn(`[storage] semantic-memory store() failed with exit code ${result.exitCode}: ${result.stderr.toString().trim()}`);
+    }
+    await this.checkLowUsageAlert();
+  }
+  async find(collection, query, limit = 10, useFts = false) {
+    const args = [
+      "find",
+      query,
+      "--collection",
+      collection,
+      "--limit",
+      String(limit),
+      "--json"
+    ];
+    if (useFts) {
+      args.push("--fts");
+    }
+    sessionStats.queriesCount++;
+    const result = await execSemanticMemory(args);
+    if (result.exitCode !== 0) {
+      console.warn(`[storage] semantic-memory find() failed with exit code ${result.exitCode}: ${result.stderr.toString().trim()}`);
+      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 (error45) {
+      console.warn(`[storage] Failed to parse semantic-memory find() output: ${error45 instanceof Error ? error45.message : String(error45)}`);
+      return [];
+    }
+  }
+  async list(collection) {
+    sessionStats.queriesCount++;
+    const result = await execSemanticMemory([
+      "list",
+      "--collection",
+      collection,
+      "--json"
+    ]);
+    if (result.exitCode !== 0) {
+      console.warn(`[storage] semantic-memory list() failed with exit code ${result.exitCode}: ${result.stderr.toString().trim()}`);
+      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 (error45) {
+      console.warn(`[storage] Failed to parse semantic-memory list() output: ${error45 instanceof Error ? error45.message : String(error45)}`);
+      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 = { ...getDefaultStorageConfig(), ...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 getResolvedCommand() {
+  return resolveSemanticMemoryCommand();
+}
+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;
+}
+async function getStorage() {
+  if (!globalStoragePromise) {
+    globalStoragePromise = createStorageWithFallback().then((storage) => {
+      globalStorage = storage;
+      return storage;
+    });
+  }
+  return globalStoragePromise;
+}
+function setStorage(storage) {
+  globalStorage = storage;
+  globalStoragePromise = Promise.resolve(storage);
+}
+async function resetStorage() {
+  if (globalStorage) {
+    await globalStorage.close();
+    globalStorage = null;
+  }
+  globalStoragePromise = null;
+}
+var cachedCommand = null, DEFAULT_STORAGE_CONFIG, sessionStats, globalStorage = null, globalStoragePromise = null;
+var init_storage = __esm(() => {
+  init_learning();
+  init_anti_patterns();
+  init_pattern_maturity();
+  DEFAULT_STORAGE_CONFIG = getDefaultStorageConfig();
+  sessionStats = {
+    storesCount: 0,
+    queriesCount: 0,
+    sessionStart: Date.now(),
+    lastAlertCheck: Date.now()
+  };
+});
+
 // ../../node_modules/.bun/effect@3.19.12/node_modules/effect/dist/esm/Function.js
 function pipe2(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
@@ -41682,6 +42587,89 @@ This will be recorded as a negative learning signal.`;
         reservationsReleaseError = error45 instanceof Error ? error45.message : String(error45);
         console.warn(`[swarm] Failed to release file reservations for ${args.agent_name}:`, error45);
       }
+      let outcomeScored = false;
+      let outcomeFeedbackType;
+      let outcomeScore;
+      let outcomeReasoning;
+      try {
+        const { scoreOutcome: scoreOutcome2, OutcomeSignalsSchema: OutcomeSignalsSchema2 } = await Promise.resolve().then(() => (init_learning(), exports_learning));
+        const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_storage(), exports_storage));
+        const { updatePatternMaturity: updatePatternMaturity2 } = await Promise.resolve().then(() => (init_pattern_maturity(), exports_pattern_maturity));
+        const durationMs = args.start_time ? Date.now() - args.start_time : 0;
+        const signals = OutcomeSignalsSchema2.parse({
+          bead_id: args.bead_id,
+          duration_ms: durationMs,
+          error_count: args.error_count ?? 0,
+          retry_count: args.retry_count ?? 0,
+          success: true,
+          files_touched: args.files_touched || [],
+          timestamp: new Date().toISOString(),
+          strategy: undefined
+        });
+        const outcome = scoreOutcome2(signals);
+        outcomeScored = true;
+        outcomeFeedbackType = outcome.type;
+        outcomeScore = outcome.score;
+        outcomeReasoning = outcome.reasoning;
+        const storage = await getStorage2();
+        const { outcomeToFeedback: outcomeToFeedback2, scoreImplicitFeedback: scoreImplicitFeedback2 } = await Promise.resolve().then(() => (init_learning(), exports_learning));
+        const scoredOutcome = scoreImplicitFeedback2(signals);
+        const feedbackEvent = outcomeToFeedback2(scoredOutcome, "task_completion");
+        await storage.storeFeedback(feedbackEvent);
+        if (signals.strategy) {
+          const maturity = await storage.getMaturity(signals.strategy);
+          if (maturity) {
+            const allFeedback = await storage.getMaturityFeedback(signals.strategy);
+            const updated = updatePatternMaturity2(maturity, allFeedback);
+            await storage.storeMaturity(updated);
+          }
+        }
+      } catch (error45) {
+        console.warn(`[swarm_complete] Failed to score outcome (non-fatal): ${error45 instanceof Error ? error45.message : String(error45)}`);
+      }
+      const patternObservations = {
+        extracted_patterns: [],
+        recorded_count: 0,
+        inversions: []
+      };
+      try {
+        const {
+          extractPatternsFromDescription: extractPatternsFromDescription2,
+          recordPatternObservation: recordPatternObservation2,
+          createPattern: createPattern2,
+          InMemoryPatternStorage: InMemoryPatternStorage2
+        } = await Promise.resolve().then(() => (init_anti_patterns(), exports_anti_patterns));
+        const epicIdForPattern = cell.parent_id || (args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id);
+        const epicCell = await adapter.getCell(args.project_key, epicIdForPattern);
+        if (epicCell?.description) {
+          const patterns = extractPatternsFromDescription2(epicCell.description);
+          patternObservations.extracted_patterns = patterns;
+          if (patterns.length > 0) {
+            const patternStorage = new InMemoryPatternStorage2;
+            for (const patternContent of patterns) {
+              const existingPatterns = await patternStorage.findByContent(patternContent);
+              let pattern = existingPatterns[0];
+              if (!pattern) {
+                pattern = createPattern2(patternContent, ["decomposition", "auto-detected"]);
+                await patternStorage.store(pattern);
+              }
+              const result = recordPatternObservation2(pattern, true, args.bead_id);
+              await patternStorage.store(result.pattern);
+              patternObservations.recorded_count++;
+              if (result.inversion) {
+                await patternStorage.store(result.inversion.inverted);
+                patternObservations.inversions.push({
+                  original: result.inversion.original.content,
+                  inverted: result.inversion.inverted.content,
+                  reason: result.inversion.reason
+                });
+              }
+            }
+          }
+        }
+      } catch (error45) {
+        console.warn(`[swarm_complete] Failed to record pattern observations (non-fatal): ${error45 instanceof Error ? error45.message : String(error45)}`);
+      }
       const epicId2 = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
       const completionBody = [
         `## Subtask Complete: ${args.bead_id}`,
@@ -41758,6 +42746,16 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
           metadata: memoryInfo.metadata,
           note: memoryStored ? "Learning automatically stored in hivemind" : `Failed to store: ${memoryError}. Learning lost unless hivemind is available.`
         },
+        outcome_scoring: outcomeScored ? {
+          scored: true,
+          feedback_type: outcomeFeedbackType,
+          score: outcomeScore,
+          reasoning: outcomeReasoning,
+          note: "Outcome scored and stored for pattern maturity tracking"
+        } : {
+          scored: false,
+          note: "Outcome scoring failed (non-fatal)"
+        },
         contract_validation: contractValidation ? {
           validated: true,
           passed: contractValidation.valid,
@@ -41767,7 +42765,8 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
         } : {
           validated: false,
           reason: "No files_owned contract found (non-epic subtask or decomposition event missing)"
-        }
+        },
+        pattern_observations: patternObservations
       };
       try {
         const { captureSubtaskOutcome: captureSubtaskOutcome2 } = await Promise.resolve().then(() => (init_eval_capture(), exports_eval_capture));