opencode-swarm-plugin 0.14.0 → 0.16.0

package/dist/index.js

@@ -28536,6 +28536,7 @@ var require_gray_matter = __commonJS((exports, module) => {
 // src/skills.ts
 var exports_skills = {};
 __export(exports_skills, {
+  validateCSOCompliance: () => validateCSOCompliance,
   skills_use: () => skills_use,
   skills_update: () => skills_update,
   skills_read: () => skills_read,
@@ -28708,6 +28709,90 @@ async function listSkills() {
 function invalidateSkillsCache() {
   skillsCache = null;
 }
+function validateCSOCompliance(name, description) {
+  const warnings = {
+    critical: [],
+    suggestions: []
+  };
+  const hasUseWhen = /\buse when\b/i.test(description);
+  if (!hasUseWhen) {
+    warnings.critical.push("Description should include 'Use when...' to focus on triggering conditions");
+  }
+  if (description.length > 1024) {
+    warnings.critical.push(`Description is ${description.length} chars (max 1024) - will be rejected`);
+  } else if (description.length > 500) {
+    warnings.suggestions.push(`Description is ${description.length} chars (aim for <500 for optimal discoverability)`);
+  }
+  const firstPersonPattern = /\b(I|I'm|I'll|my|mine|myself)\b/i;
+  const secondPersonPattern = /\b(you|you're|you'll|your|yours|yourself)\b/i;
+  if (firstPersonPattern.test(description)) {
+    warnings.critical.push("Description uses first-person ('I', 'my') - skills are injected into system prompt, use third-person only");
+  }
+  if (secondPersonPattern.test(description)) {
+    warnings.critical.push("Description uses second-person ('you', 'your') - use third-person voice (e.g., 'Handles X' not 'You can handle X')");
+  }
+  const nameWords = name.split("-");
+  const firstWord = nameWords[0];
+  const isGerund = /ing$/.test(firstWord);
+  const isVerbForm = /(ing|ize|ify|ate)$/.test(firstWord);
+  if (!isGerund && !isVerbForm) {
+    const actionVerbs = [
+      "test",
+      "debug",
+      "fix",
+      "scan",
+      "check",
+      "validate",
+      "create",
+      "build",
+      "deploy",
+      "run",
+      "load",
+      "fetch",
+      "parse"
+    ];
+    const startsWithAction = actionVerbs.includes(firstWord);
+    if (!startsWithAction) {
+      warnings.suggestions.push(`Name '${name}' doesn't follow verb-first pattern. Consider gerunds (e.g., 'testing-skills' not 'test-skill') or action verbs for better clarity`);
+    }
+  }
+  if (name.length > 64) {
+    warnings.critical.push(`Name exceeds 64 character limit (${name.length} chars)`);
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    warnings.critical.push("Name must be lowercase letters, numbers, and hyphens only");
+  }
+  return warnings;
+}
+function formatCSOWarnings(warnings) {
+  if (warnings.critical.length === 0 && warnings.suggestions.length === 0) {
+    return null;
+  }
+  const parts = [];
+  if (warnings.critical.length > 0) {
+    parts.push("**CSO Critical Issues:**");
+    for (const warning of warnings.critical) {
+      parts.push(`  ⚠️  ${warning}`);
+    }
+  }
+  if (warnings.suggestions.length > 0) {
+    parts.push(`
+**CSO Suggestions:**`);
+    for (const suggestion of warnings.suggestions) {
+      parts.push(`  \uD83D\uDCA1 ${suggestion}`);
+    }
+  }
+  parts.push(`
+**CSO Guide:**`);
+  parts.push("  • Start description with 'Use when...' (focus on triggering conditions)");
+  parts.push("  • Keep description <500 chars (max 1024)");
+  parts.push("  • Use third-person voice only (injected into system prompt)");
+  parts.push("  • Name: verb-first or gerunds (e.g., 'testing-async' not 'async-test')");
+  parts.push(`
+  Example: 'Use when tests have race conditions - replaces arbitrary timeouts with condition polling'`);
+  return parts.join(`
+`);
+}
 function quoteYamlScalar(value) {
   const needsQuoting = /[:\n\r#"'`\[\]{}|>&*!?@]/.test(value) || value.startsWith(" ") || value.endsWith(" ") || value === "" || /^[0-9]/.test(value) || ["true", "false", "null", "yes", "no", "on", "off"].includes(value.toLowerCase());
   if (!needsQuoting) {
@@ -29059,6 +29144,7 @@ Good skills have:
       if (existing) {
         return `Skill '${args.name}' already exists at ${existing.path}. Use skills_update to modify it.`;
       }
+      const csoWarnings = validateCSOCompliance(args.name, args.description);
       let skillDir;
       if (args.directory === "global") {
         skillDir = join5(getGlobalSkillsDir(), args.name);
@@ -29074,7 +29160,7 @@ Good skills have:
         const content = generateSkillContent(args.name, args.description, args.body, { tags: args.tags, tools: args.tools });
         await writeFile(skillPath, content, "utf-8");
         invalidateSkillsCache();
-        return JSON.stringify({
+        const response = {
           success: true,
           skill: args.name,
           path: skillPath,
@@ -29084,7 +29170,12 @@ Good skills have:
             "Add examples.md or reference.md for supplementary content",
             "Add scripts/ directory for executable helpers"
           ]
-        }, null, 2);
+        };
+        const warningsMessage = formatCSOWarnings(csoWarnings);
+        if (warningsMessage) {
+          response.cso_warnings = warningsMessage;
+        }
+        return JSON.stringify(response, null, 2);
       } catch (error45) {
         return `Failed to create skill: ${error45 instanceof Error ? error45.message : String(error45)}`;
       }
@@ -29577,6 +29668,96 @@ var SwarmStatusSchema = exports_external.object({
   agents: exports_external.array(SpawnedAgentSchema),
   last_update: exports_external.string().datetime({ offset: true })
 });
+// src/schemas/mandate.ts
+init_zod();
+var MandateContentTypeSchema = exports_external.enum([
+  "idea",
+  "tip",
+  "lore",
+  "snippet",
+  "feature_request"
+]);
+var MandateStatusSchema = exports_external.enum([
+  "candidate",
+  "established",
+  "mandate",
+  "rejected"
+]);
+var VoteTypeSchema = exports_external.enum(["upvote", "downvote"]);
+var MandateEntrySchema = exports_external.object({
+  id: exports_external.string(),
+  content: exports_external.string().min(1, "Content required"),
+  content_type: MandateContentTypeSchema,
+  author_agent: exports_external.string(),
+  created_at: exports_external.string().datetime({ offset: true }),
+  status: MandateStatusSchema.default("candidate"),
+  tags: exports_external.array(exports_external.string()).default([]),
+  metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+});
+var VoteSchema = exports_external.object({
+  id: exports_external.string(),
+  mandate_id: exports_external.string(),
+  agent_name: exports_external.string(),
+  vote_type: VoteTypeSchema,
+  timestamp: exports_external.string().datetime({ offset: true }),
+  weight: exports_external.number().min(0).max(1).default(1)
+});
+var MandateScoreSchema = exports_external.object({
+  mandate_id: exports_external.string(),
+  net_votes: exports_external.number(),
+  vote_ratio: exports_external.number().min(0).max(1),
+  decayed_score: exports_external.number(),
+  last_calculated: exports_external.string().datetime({ offset: true }),
+  raw_upvotes: exports_external.number().int().min(0),
+  raw_downvotes: exports_external.number().int().min(0),
+  decayed_upvotes: exports_external.number().min(0),
+  decayed_downvotes: exports_external.number().min(0)
+});
+var DEFAULT_MANDATE_DECAY_CONFIG = {
+  halfLifeDays: 90,
+  mandateNetVotesThreshold: 5,
+  mandateVoteRatioThreshold: 0.7,
+  establishedNetVotesThreshold: 2,
+  rejectedNetVotesThreshold: -3
+};
+var CreateMandateArgsSchema = exports_external.object({
+  content: exports_external.string().min(1, "Content required"),
+  content_type: MandateContentTypeSchema,
+  tags: exports_external.array(exports_external.string()).default([]),
+  metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+});
+var CastVoteArgsSchema = exports_external.object({
+  mandate_id: exports_external.string(),
+  vote_type: VoteTypeSchema,
+  weight: exports_external.number().min(0).max(1).default(1)
+});
+var QueryMandatesArgsSchema = exports_external.object({
+  status: MandateStatusSchema.optional(),
+  content_type: MandateContentTypeSchema.optional(),
+  tags: exports_external.array(exports_external.string()).optional(),
+  author_agent: exports_external.string().optional(),
+  limit: exports_external.number().int().positive().default(20),
+  min_score: exports_external.number().optional()
+});
+var ScoreCalculationResultSchema = exports_external.object({
+  mandate_id: exports_external.string(),
+  previous_status: MandateStatusSchema,
+  new_status: MandateStatusSchema,
+  score: MandateScoreSchema,
+  status_changed: exports_external.boolean()
+});
+var mandateSchemas = {
+  MandateContentTypeSchema,
+  MandateStatusSchema,
+  VoteTypeSchema,
+  MandateEntrySchema,
+  VoteSchema,
+  MandateScoreSchema,
+  CreateMandateArgsSchema,
+  CastVoteArgsSchema,
+  QueryMandatesArgsSchema,
+  ScoreCalculationResultSchema
+};
 // src/beads.ts
 var beadsWorkingDirectory = null;
 function setBeadsWorkingDirectory(directory) {
@@ -32378,6 +32559,89 @@ class InMemoryFeedbackStorage {
     return [...this.events];
   }
 }
+var StrikeRecordSchema = exports_external.object({
+  bead_id: exports_external.string(),
+  strike_count: exports_external.number().int().min(0).max(3),
+  failures: exports_external.array(exports_external.object({
+    attempt: exports_external.string(),
+    reason: exports_external.string(),
+    timestamp: exports_external.string()
+  })),
+  first_strike_at: exports_external.string().optional(),
+  last_strike_at: exports_external.string().optional()
+});
+
+class InMemoryStrikeStorage {
+  strikes = new Map;
+  async store(record2) {
+    this.strikes.set(record2.bead_id, record2);
+  }
+  async get(beadId) {
+    return this.strikes.get(beadId) ?? null;
+  }
+  async getAll() {
+    return Array.from(this.strikes.values());
+  }
+  async clear(beadId) {
+    this.strikes.delete(beadId);
+  }
+}
+async function addStrike(beadId, attempt, reason, storage = new InMemoryStrikeStorage) {
+  const existing = await storage.get(beadId);
+  const now = new Date().toISOString();
+  const record2 = existing ?? {
+    bead_id: beadId,
+    strike_count: 0,
+    failures: []
+  };
+  record2.strike_count = Math.min(3, record2.strike_count + 1);
+  record2.failures.push({ attempt, reason, timestamp: now });
+  record2.last_strike_at = now;
+  if (!record2.first_strike_at) {
+    record2.first_strike_at = now;
+  }
+  await storage.store(record2);
+  return record2;
+}
+async function getStrikes(beadId, storage = new InMemoryStrikeStorage) {
+  const record2 = await storage.get(beadId);
+  return record2?.strike_count ?? 0;
+}
+async function isStrikedOut(beadId, storage = new InMemoryStrikeStorage) {
+  const count = await getStrikes(beadId, storage);
+  return count >= 3;
+}
+async function getArchitecturePrompt(beadId, storage = new InMemoryStrikeStorage) {
+  const record2 = await storage.get(beadId);
+  if (!record2 || record2.strike_count < 3) {
+    return "";
+  }
+  const failuresList = record2.failures.map((f, i) => `${i + 1}. **${f.attempt}** - Failed: ${f.reason}`).join(`
+`);
+  return `## Architecture Review Required
+
+This bead (\`${beadId}\`) has failed 3 consecutive fix attempts:
+
+${failuresList}
+
+This pattern suggests an **architectural problem**, not a bug.
+
+**Questions to consider:**
+- Is the current approach fundamentally sound?
+- Should we refactor the architecture instead?
+- Are we fixing symptoms instead of root cause?
+
+**Options:**
+1. **Refactor architecture** (describe new approach)
+2. **Continue with Fix #4** (explain why this time is different)
+3. **Abandon this approach entirely**
+
+**DO NOT attempt Fix #4 without answering these questions.**
+`;
+}
+async function clearStrikes(beadId, storage = new InMemoryStrikeStorage) {
+  await storage.clear(beadId);
+}
 
 class InMemoryErrorStorage {
   errors = [];
@@ -32897,7 +33161,7 @@ You MUST keep your bead updated as you work:
 
 **Never work silently.** Your bead status is how the swarm tracks progress.
 
-## MANDATORY: Agent Mail Communication
+## MANDATORY: Swarm Mail Communication
 
 You MUST communicate with other agents:
 
@@ -32906,9 +33170,9 @@ You MUST communicate with other agents:
 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:
+Use Swarm Mail for all communication:
 \`\`\`
-agentmail_send(
+swarmmail_send(
   to: ["coordinator" or specific agent],
   subject: "Brief subject",
   body: "Message content",
@@ -32920,7 +33184,7 @@ agentmail_send(
 
 1. **Start**: Your bead is already marked in_progress
 2. **Progress**: Use swarm_progress to report status updates
-3. **Blocked**: Report immediately via Agent Mail - don't spin
+3. **Blocked**: Report immediately via Swarm Mail - don't spin
 4. **Complete**: Use swarm_complete when done - it handles:
    - Closing your bead with a summary
    - Releasing file reservations
@@ -32942,7 +33206,7 @@ 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
+4. **Communicate your plan** via Swarm Mail if non-trivial
 
 Begin work on your subtask now.`;
 var SUBTASK_PROMPT_V2 = `You are a swarm agent working on: **{subtask_title}**
@@ -33653,6 +33917,139 @@ var swarm_progress = tool({
     return `Progress reported: ${args.status}${args.progress_percent !== undefined ? ` (${args.progress_percent}%)` : ""}`;
   }
 });
+async function runTypecheckVerification() {
+  const step = {
+    name: "typecheck",
+    command: "tsc --noEmit",
+    passed: false,
+    exitCode: -1
+  };
+  try {
+    const tsconfigExists = await Bun.file("tsconfig.json").exists();
+    if (!tsconfigExists) {
+      step.skipped = true;
+      step.skipReason = "No tsconfig.json found";
+      step.passed = true;
+      return step;
+    }
+    const result = await Bun.$`tsc --noEmit`.quiet().nothrow();
+    step.exitCode = result.exitCode;
+    step.passed = result.exitCode === 0;
+    if (!step.passed) {
+      step.error = result.stderr.toString().slice(0, 1000);
+      step.output = result.stdout.toString().slice(0, 1000);
+    }
+  } catch (error45) {
+    step.skipped = true;
+    step.skipReason = `tsc not available: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    step.passed = true;
+  }
+  return step;
+}
+async function runTestVerification(filesTouched) {
+  const step = {
+    name: "tests",
+    command: "bun test <related-files>",
+    passed: false,
+    exitCode: -1
+  };
+  if (filesTouched.length === 0) {
+    step.skipped = true;
+    step.skipReason = "No files touched";
+    step.passed = true;
+    return step;
+  }
+  const testPatterns = [];
+  for (const file2 of filesTouched) {
+    if (file2.includes(".test.") || file2.includes(".spec.")) {
+      testPatterns.push(file2);
+      continue;
+    }
+    const baseName = file2.replace(/\.(ts|tsx|js|jsx)$/, "");
+    testPatterns.push(`${baseName}.test.ts`);
+    testPatterns.push(`${baseName}.test.tsx`);
+    testPatterns.push(`${baseName}.spec.ts`);
+  }
+  const existingTests = [];
+  for (const pattern of testPatterns) {
+    try {
+      const exists = await Bun.file(pattern).exists();
+      if (exists) {
+        existingTests.push(pattern);
+      }
+    } catch {}
+  }
+  if (existingTests.length === 0) {
+    step.skipped = true;
+    step.skipReason = "No related test files found";
+    step.passed = true;
+    return step;
+  }
+  try {
+    step.command = `bun test ${existingTests.join(" ")}`;
+    const result = await Bun.$`bun test ${existingTests}`.quiet().nothrow();
+    step.exitCode = result.exitCode;
+    step.passed = result.exitCode === 0;
+    if (!step.passed) {
+      step.error = result.stderr.toString().slice(0, 1000);
+      step.output = result.stdout.toString().slice(0, 1000);
+    }
+  } catch (error45) {
+    step.skipped = true;
+    step.skipReason = `Test runner failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    step.passed = true;
+  }
+  return step;
+}
+async function runVerificationGate(filesTouched, skipUbs = false) {
+  const steps = [];
+  const blockers = [];
+  if (!skipUbs && filesTouched.length > 0) {
+    const ubsResult = await runUbsScan(filesTouched);
+    if (ubsResult) {
+      const ubsStep = {
+        name: "ubs_scan",
+        command: `ubs scan ${filesTouched.join(" ")}`,
+        passed: ubsResult.summary.critical === 0,
+        exitCode: ubsResult.exitCode
+      };
+      if (!ubsStep.passed) {
+        ubsStep.error = `Found ${ubsResult.summary.critical} critical bugs`;
+        blockers.push(`UBS: ${ubsResult.summary.critical} critical bugs found`);
+      }
+      steps.push(ubsStep);
+    } else {
+      steps.push({
+        name: "ubs_scan",
+        command: "ubs scan",
+        passed: true,
+        exitCode: 0,
+        skipped: true,
+        skipReason: "UBS not available"
+      });
+    }
+  }
+  const typecheckStep = await runTypecheckVerification();
+  steps.push(typecheckStep);
+  if (!typecheckStep.passed && !typecheckStep.skipped) {
+    blockers.push(`Typecheck: ${typecheckStep.error?.slice(0, 100) || "failed"}`);
+  }
+  const testStep = await runTestVerification(filesTouched);
+  steps.push(testStep);
+  if (!testStep.passed && !testStep.skipped) {
+    blockers.push(`Tests: ${testStep.error?.slice(0, 100) || "failed"}`);
+  }
+  const passedCount = steps.filter((s) => s.passed).length;
+  const skippedCount = steps.filter((s) => s.skipped).length;
+  const failedCount = steps.filter((s) => !s.passed && !s.skipped).length;
+  const summary = failedCount === 0 ? `Verification passed: ${passedCount} checks passed, ${skippedCount} skipped` : `Verification FAILED: ${failedCount} checks failed, ${passedCount} passed, ${skippedCount} skipped`;
+  return {
+    passed: failedCount === 0,
+    steps,
+    summary,
+    blockers
+  };
+}
 async function runUbsScan(files) {
   if (files.length === 0) {
     return null;
@@ -33755,19 +34152,44 @@ ${args.files_affected.map((f) => `- \`${f}\``).join(`
   }
 });
 var swarm_complete = tool({
-  description: "Mark subtask complete, release reservations, notify coordinator. Runs UBS bug scan if files_touched provided.",
+  description: "Mark subtask complete with Verification Gate. Runs UBS scan, typecheck, and tests before allowing completion.",
   args: {
     project_key: tool.schema.string().describe("Project path"),
     agent_name: tool.schema.string().describe("Your Agent Mail name"),
     bead_id: tool.schema.string().describe("Subtask bead ID"),
     summary: tool.schema.string().describe("Brief summary of work done"),
     evaluation: tool.schema.string().optional().describe("Self-evaluation JSON (Evaluation schema)"),
-    files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified - will be scanned by UBS for bugs"),
-    skip_ubs_scan: tool.schema.boolean().optional().describe("Skip UBS bug scan (default: false)")
+    files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified - will be verified (UBS, typecheck, tests)"),
+    skip_ubs_scan: tool.schema.boolean().optional().describe("Skip UBS bug scan (default: false)"),
+    skip_verification: tool.schema.boolean().optional().describe("Skip ALL verification (UBS, typecheck, tests). Use sparingly! (default: false)")
   },
   async execute(args) {
+    let verificationResult = null;
+    if (!args.skip_verification && args.files_touched?.length) {
+      verificationResult = await runVerificationGate(args.files_touched, args.skip_ubs_scan ?? false);
+      if (!verificationResult.passed) {
+        return JSON.stringify({
+          success: false,
+          error: "Verification Gate FAILED - fix issues before completing",
+          verification: {
+            passed: false,
+            summary: verificationResult.summary,
+            blockers: verificationResult.blockers,
+            steps: verificationResult.steps.map((s) => ({
+              name: s.name,
+              passed: s.passed,
+              skipped: s.skipped,
+              skipReason: s.skipReason,
+              error: s.error?.slice(0, 200)
+            }))
+          },
+          hint: "Fix the failing checks and try again. Use skip_verification=true only as last resort.",
+          gate_function: "IDENTIFY → RUN → READ → VERIFY → CLAIM (you are at VERIFY, claim blocked)"
+        }, null, 2);
+      }
+    }
     let ubsResult = null;
-    if (args.files_touched && args.files_touched.length > 0 && !args.skip_ubs_scan) {
+    if (!args.skip_verification && !verificationResult && args.files_touched?.length && !args.skip_ubs_scan) {
       ubsResult = await runUbsScan(args.files_touched);
       if (ubsResult && ubsResult.summary.critical > 0) {
         return JSON.stringify({
@@ -33838,12 +34260,22 @@ var swarm_complete = tool({
       closed: true,
       reservations_released: true,
       message_sent: true,
+      verification_gate: verificationResult ? {
+        passed: true,
+        summary: verificationResult.summary,
+        steps: verificationResult.steps.map((s) => ({
+          name: s.name,
+          passed: s.passed,
+          skipped: s.skipped,
+          skipReason: s.skipReason
+        }))
+      } : args.skip_verification ? { skipped: true, reason: "skip_verification=true" } : { skipped: true, reason: "no files_touched provided" },
       ubs_scan: ubsResult ? {
         ran: true,
         bugs_found: ubsResult.summary.total,
         summary: ubsResult.summary,
         warnings: ubsResult.bugs.filter((b) => b.severity !== "critical")
-      } : {
+      } : verificationResult ? { ran: true, included_in_verification_gate: true } : {
         ran: false,
         reason: args.skip_ubs_scan ? "skipped" : "no files or ubs unavailable"
       },
@@ -34411,6 +34843,77 @@ var swarmTools = {
   swarm_get_error_context,
   swarm_resolve_error
 };
+var globalStrikeStorage = new InMemoryStrikeStorage;
+var swarm_check_strikes = tool({
+  description: "Check 3-strike status for a bead. Records failures, detects architectural problems, generates architecture review prompts.",
+  args: {
+    bead_id: tool.schema.string().describe("Bead ID to check"),
+    action: tool.schema.enum(["check", "add_strike", "clear", "get_prompt"]).describe("Action: check count, add strike, clear strikes, or get prompt"),
+    attempt: tool.schema.string().optional().describe("Description of fix attempt (required for add_strike)"),
+    reason: tool.schema.string().optional().describe("Why the fix failed (required for add_strike)")
+  },
+  async execute(args) {
+    switch (args.action) {
+      case "check": {
+        const count = await getStrikes(args.bead_id, globalStrikeStorage);
+        const strikedOut = await isStrikedOut(args.bead_id, globalStrikeStorage);
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          strike_count: count,
+          is_striked_out: strikedOut,
+          message: strikedOut ? "⚠️ STRUCK OUT: 3 strikes reached. Use get_prompt action for architecture review." : count === 0 ? "No strikes. Clear to proceed." : `${count} strike${count > 1 ? "s" : ""}. ${3 - count} remaining before architecture review required.`,
+          next_action: strikedOut ? "Call with action=get_prompt to get architecture review questions" : "Continue with fix attempt"
+        }, null, 2);
+      }
+      case "add_strike": {
+        if (!args.attempt || !args.reason) {
+          return JSON.stringify({
+            error: "add_strike requires 'attempt' and 'reason' parameters"
+          }, null, 2);
+        }
+        const record2 = await addStrike(args.bead_id, args.attempt, args.reason, globalStrikeStorage);
+        const strikedOut = record2.strike_count >= 3;
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          strike_count: record2.strike_count,
+          is_striked_out: strikedOut,
+          failures: record2.failures,
+          message: strikedOut ? "⚠️ STRUCK OUT: 3 strikes reached. STOP and question the architecture." : `Strike ${record2.strike_count} recorded. ${3 - record2.strike_count} remaining.`,
+          warning: strikedOut ? "DO NOT attempt Fix #4. Call with action=get_prompt for architecture review." : undefined
+        }, null, 2);
+      }
+      case "clear": {
+        await clearStrikes(args.bead_id, globalStrikeStorage);
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          strike_count: 0,
+          is_striked_out: false,
+          message: "Strikes cleared. Fresh start."
+        }, null, 2);
+      }
+      case "get_prompt": {
+        const prompt = await getArchitecturePrompt(args.bead_id, globalStrikeStorage);
+        if (!prompt) {
+          return JSON.stringify({
+            bead_id: args.bead_id,
+            has_prompt: false,
+            message: "No architecture prompt (not struck out yet)"
+          }, null, 2);
+        }
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          has_prompt: true,
+          architecture_review_prompt: prompt,
+          message: "Architecture review required. Present this prompt to the human partner."
+        }, null, 2);
+      }
+      default:
+        return JSON.stringify({
+          error: `Unknown action: ${args.action}`
+        }, null, 2);
+    }
+  }
+});
 
 // src/repo-crawl.ts
 init_dist();
@@ -34737,6 +35240,762 @@ var repoCrawlTools = {
 // src/index.ts
 init_skills();
 
+// src/mandates.ts
+init_dist();
+
+// src/mandate-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) {
+  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}`)
+    };
+  }
+}
+var DEFAULT_MANDATE_STORAGE_CONFIG = {
+  backend: "semantic-memory",
+  collections: {
+    mandates: "swarm-mandates",
+    votes: "swarm-votes"
+  },
+  decay: DEFAULT_MANDATE_DECAY_CONFIG,
+  useSemanticSearch: true
+};
+
+class SemanticMemoryMandateStorage {
+  config;
+  constructor(config2 = {}) {
+    this.config = { ...DEFAULT_MANDATE_STORAGE_CONFIG, ...config2 };
+  }
+  async storeInternal(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 findInternal(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) {
+      console.warn(`[mandate-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(`[mandate-storage] Failed to parse semantic-memory find() output: ${error45 instanceof Error ? error45.message : String(error45)}`);
+      return [];
+    }
+  }
+  async listInternal(collection) {
+    const result = await execSemanticMemory([
+      "list",
+      "--collection",
+      collection,
+      "--json"
+    ]);
+    if (result.exitCode !== 0) {
+      console.warn(`[mandate-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(`[mandate-storage] Failed to parse semantic-memory list() output: ${error45 instanceof Error ? error45.message : String(error45)}`);
+      return [];
+    }
+  }
+  async store(entry) {
+    await this.storeInternal(this.config.collections.mandates, entry, {
+      id: entry.id,
+      content_type: entry.content_type,
+      author_agent: entry.author_agent,
+      status: entry.status,
+      tags: entry.tags.join(","),
+      created_at: entry.created_at
+    });
+  }
+  async get(id) {
+    const all = await this.listInternal(this.config.collections.mandates);
+    return all.find((entry) => entry.id === id) || null;
+  }
+  async find(query, limit = 10) {
+    return this.findInternal(this.config.collections.mandates, query, limit, !this.config.useSemanticSearch);
+  }
+  async list(filter2) {
+    const all = await this.listInternal(this.config.collections.mandates);
+    if (!filter2)
+      return all;
+    return all.filter((entry) => {
+      if (filter2.status && entry.status !== filter2.status)
+        return false;
+      if (filter2.content_type && entry.content_type !== filter2.content_type)
+        return false;
+      return true;
+    });
+  }
+  async update(id, updates) {
+    const existing = await this.get(id);
+    if (!existing) {
+      throw new Error(`Mandate ${id} not found`);
+    }
+    const updated = { ...existing, ...updates };
+    await this.store(updated);
+  }
+  async vote(vote) {
+    const existing = await this.hasVoted(vote.mandate_id, vote.agent_name);
+    if (existing) {
+      throw new Error(`Agent ${vote.agent_name} has already voted on mandate ${vote.mandate_id}`);
+    }
+    await this.storeInternal(this.config.collections.votes, vote, {
+      id: vote.id,
+      mandate_id: vote.mandate_id,
+      agent_name: vote.agent_name,
+      vote_type: vote.vote_type,
+      timestamp: vote.timestamp,
+      weight: vote.weight
+    });
+  }
+  async getVotes(mandateId) {
+    const all = await this.listInternal(this.config.collections.votes);
+    return all.filter((vote) => vote.mandate_id === mandateId);
+  }
+  async hasVoted(mandateId, agentName) {
+    const votes = await this.getVotes(mandateId);
+    return votes.some((vote) => vote.agent_name === agentName);
+  }
+  async calculateScore(mandateId) {
+    const votes = await this.getVotes(mandateId);
+    const now = new Date;
+    let rawUpvotes = 0;
+    let rawDownvotes = 0;
+    let decayedUpvotes = 0;
+    let decayedDownvotes = 0;
+    for (const vote of votes) {
+      const decayed = calculateDecayedValue(vote.timestamp, now, this.config.decay.halfLifeDays);
+      const value = vote.weight * decayed;
+      if (vote.vote_type === "upvote") {
+        rawUpvotes++;
+        decayedUpvotes += value;
+      } else {
+        rawDownvotes++;
+        decayedDownvotes += value;
+      }
+    }
+    const totalDecayed = decayedUpvotes + decayedDownvotes;
+    const voteRatio = totalDecayed > 0 ? decayedUpvotes / totalDecayed : 0;
+    const netVotes = decayedUpvotes - decayedDownvotes;
+    const decayedScore = netVotes * voteRatio;
+    return {
+      mandate_id: mandateId,
+      net_votes: netVotes,
+      vote_ratio: voteRatio,
+      decayed_score: decayedScore,
+      last_calculated: now.toISOString(),
+      raw_upvotes: rawUpvotes,
+      raw_downvotes: rawDownvotes,
+      decayed_upvotes: decayedUpvotes,
+      decayed_downvotes: decayedDownvotes
+    };
+  }
+  async close() {}
+}
+
+class InMemoryMandateStorage {
+  entries = new Map;
+  votes = new Map;
+  config;
+  constructor(config2 = {}) {
+    const fullConfig = { ...DEFAULT_MANDATE_STORAGE_CONFIG, ...config2 };
+    this.config = fullConfig.decay;
+  }
+  async store(entry) {
+    this.entries.set(entry.id, entry);
+  }
+  async get(id) {
+    return this.entries.get(id) || null;
+  }
+  async find(query, limit = 10) {
+    const lowerQuery = query.toLowerCase();
+    const results = Array.from(this.entries.values()).filter((entry) => entry.content.toLowerCase().includes(lowerQuery) || entry.tags.some((tag) => tag.toLowerCase().includes(lowerQuery)));
+    return results.slice(0, limit);
+  }
+  async list(filter2) {
+    let results = Array.from(this.entries.values());
+    if (filter2) {
+      results = results.filter((entry) => {
+        if (filter2.status && entry.status !== filter2.status)
+          return false;
+        if (filter2.content_type && entry.content_type !== filter2.content_type)
+          return false;
+        return true;
+      });
+    }
+    return results;
+  }
+  async update(id, updates) {
+    const existing = await this.get(id);
+    if (!existing) {
+      throw new Error(`Mandate ${id} not found`);
+    }
+    const updated = { ...existing, ...updates };
+    this.entries.set(id, updated);
+  }
+  async vote(vote) {
+    const existing = await this.hasVoted(vote.mandate_id, vote.agent_name);
+    if (existing) {
+      throw new Error(`Agent ${vote.agent_name} has already voted on mandate ${vote.mandate_id}`);
+    }
+    this.votes.set(vote.id, vote);
+  }
+  async getVotes(mandateId) {
+    return Array.from(this.votes.values()).filter((vote) => vote.mandate_id === mandateId);
+  }
+  async hasVoted(mandateId, agentName) {
+    const votes = await this.getVotes(mandateId);
+    return votes.some((vote) => vote.agent_name === agentName);
+  }
+  async calculateScore(mandateId) {
+    const votes = await this.getVotes(mandateId);
+    const now = new Date;
+    let rawUpvotes = 0;
+    let rawDownvotes = 0;
+    let decayedUpvotes = 0;
+    let decayedDownvotes = 0;
+    for (const vote of votes) {
+      const decayed = calculateDecayedValue(vote.timestamp, now, this.config.halfLifeDays);
+      const value = vote.weight * decayed;
+      if (vote.vote_type === "upvote") {
+        rawUpvotes++;
+        decayedUpvotes += value;
+      } else {
+        rawDownvotes++;
+        decayedDownvotes += value;
+      }
+    }
+    const totalDecayed = decayedUpvotes + decayedDownvotes;
+    const voteRatio = totalDecayed > 0 ? decayedUpvotes / totalDecayed : 0;
+    const netVotes = decayedUpvotes - decayedDownvotes;
+    const decayedScore = netVotes * voteRatio;
+    return {
+      mandate_id: mandateId,
+      net_votes: netVotes,
+      vote_ratio: voteRatio,
+      decayed_score: decayedScore,
+      last_calculated: now.toISOString(),
+      raw_upvotes: rawUpvotes,
+      raw_downvotes: rawDownvotes,
+      decayed_upvotes: decayedUpvotes,
+      decayed_downvotes: decayedDownvotes
+    };
+  }
+  async close() {}
+}
+function createMandateStorage(config2 = {}) {
+  const fullConfig = { ...DEFAULT_MANDATE_STORAGE_CONFIG, ...config2 };
+  switch (fullConfig.backend) {
+    case "semantic-memory":
+      return new SemanticMemoryMandateStorage(fullConfig);
+    case "memory":
+      return new InMemoryMandateStorage(fullConfig);
+    default:
+      throw new Error(`Unknown storage backend: ${fullConfig.backend}`);
+  }
+}
+async function updateMandateStatus(mandateId, storage) {
+  const entry = await storage.get(mandateId);
+  if (!entry) {
+    throw new Error(`Mandate ${mandateId} not found`);
+  }
+  const score = await storage.calculateScore(mandateId);
+  const previousStatus = entry.status;
+  let newStatus;
+  const config2 = DEFAULT_MANDATE_DECAY_CONFIG;
+  if (score.net_votes >= config2.mandateNetVotesThreshold && score.vote_ratio >= config2.mandateVoteRatioThreshold) {
+    newStatus = "mandate";
+  } else if (score.net_votes <= config2.rejectedNetVotesThreshold) {
+    newStatus = "rejected";
+  } else if (score.net_votes >= config2.establishedNetVotesThreshold) {
+    newStatus = "established";
+  } else {
+    newStatus = "candidate";
+  }
+  if (newStatus !== previousStatus) {
+    await storage.update(mandateId, { status: newStatus });
+  }
+  return {
+    mandate_id: mandateId,
+    previous_status: previousStatus,
+    new_status: newStatus,
+    score,
+    status_changed: newStatus !== previousStatus
+  };
+}
+async function updateAllMandateStatuses(storage) {
+  const allEntries = await storage.list();
+  const results = [];
+  for (const entry of allEntries) {
+    const result = await updateMandateStatus(entry.id, storage);
+    results.push(result);
+  }
+  return results;
+}
+var globalMandateStorage = null;
+function getMandateStorage() {
+  if (!globalMandateStorage) {
+    globalMandateStorage = createMandateStorage();
+  }
+  return globalMandateStorage;
+}
+function setMandateStorage(storage) {
+  globalMandateStorage = storage;
+}
+async function resetMandateStorage() {
+  if (globalMandateStorage) {
+    await globalMandateStorage.close();
+    globalMandateStorage = null;
+  }
+}
+
+// src/mandate-promotion.ts
+function shouldPromote(score, currentStatus, config2 = DEFAULT_MANDATE_DECAY_CONFIG) {
+  if (currentStatus === "rejected") {
+    return "rejected";
+  }
+  if (currentStatus === "mandate") {
+    return "mandate";
+  }
+  if (score.net_votes <= config2.rejectedNetVotesThreshold) {
+    return "rejected";
+  }
+  if (currentStatus === "established") {
+    if (score.net_votes >= config2.mandateNetVotesThreshold && score.vote_ratio >= config2.mandateVoteRatioThreshold) {
+      return "mandate";
+    }
+    return "established";
+  }
+  if (score.net_votes >= config2.establishedNetVotesThreshold) {
+    return "established";
+  }
+  return "candidate";
+}
+function evaluatePromotion(entry, score, config2 = DEFAULT_MANDATE_DECAY_CONFIG) {
+  const previousStatus = entry.status;
+  const newStatus = shouldPromote(score, previousStatus, config2);
+  const promoted = newStatus !== previousStatus;
+  let reason;
+  if (newStatus === "rejected" && previousStatus === "rejected") {
+    reason = `Remains rejected (permanent)`;
+  } else if (newStatus === "rejected") {
+    reason = `Rejected due to negative consensus (net_votes: ${score.net_votes.toFixed(2)} ≤ ${config2.rejectedNetVotesThreshold})`;
+  } else if (newStatus === "mandate" && previousStatus === "mandate") {
+    reason = `Remains mandate (no demotion)`;
+  } else if (newStatus === "mandate" && previousStatus === "established") {
+    reason = `Promoted to mandate (net_votes: ${score.net_votes.toFixed(2)} ≥ ${config2.mandateNetVotesThreshold}, ratio: ${score.vote_ratio.toFixed(2)} ≥ ${config2.mandateVoteRatioThreshold})`;
+  } else if (newStatus === "established" && previousStatus === "established") {
+    reason = `Remains established (net_votes: ${score.net_votes.toFixed(2)}, ratio: ${score.vote_ratio.toFixed(2)} below mandate threshold)`;
+  } else if (newStatus === "established" && previousStatus === "candidate") {
+    reason = `Promoted to established (net_votes: ${score.net_votes.toFixed(2)} ≥ ${config2.establishedNetVotesThreshold})`;
+  } else if (newStatus === "candidate") {
+    reason = `Remains candidate (net_votes: ${score.net_votes.toFixed(2)} below threshold)`;
+  } else {
+    reason = `No status change (current: ${previousStatus})`;
+  }
+  return {
+    mandate_id: entry.id,
+    previous_status: previousStatus,
+    new_status: newStatus,
+    score,
+    promoted,
+    reason
+  };
+}
+function formatPromotionResult(result) {
+  const arrow = result.promoted ? `${result.previous_status} → ${result.new_status}` : result.new_status;
+  return `[${result.mandate_id}] ${arrow}: ${result.reason}`;
+}
+function evaluateBatchPromotions(entries, scores, config2 = DEFAULT_MANDATE_DECAY_CONFIG) {
+  const results = [];
+  for (const [id, entry] of entries) {
+    const score = scores.get(id);
+    if (!score) {
+      continue;
+    }
+    const result = evaluatePromotion(entry, score, config2);
+    results.push(result);
+  }
+  return results;
+}
+function getStatusChanges(results) {
+  return results.filter((r) => r.promoted);
+}
+function groupByTransition(results) {
+  const groups = new Map;
+  for (const result of results) {
+    const key = result.promoted ? `${result.previous_status}→${result.new_status}` : result.new_status;
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(result);
+    } else {
+      groups.set(key, [result]);
+    }
+  }
+  return groups;
+}
+
+// src/mandates.ts
+class MandateError extends Error {
+  operation;
+  details;
+  constructor(message, operation, details) {
+    super(message);
+    this.operation = operation;
+    this.details = details;
+    this.name = "MandateError";
+  }
+}
+function generateMandateId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `mandate-${timestamp}-${random}`;
+}
+function generateVoteId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `vote-${timestamp}-${random}`;
+}
+var mandate_file = tool({
+  description: "Submit a new idea, tip, lore, snippet, or feature request to the mandate system",
+  args: {
+    content: tool.schema.string().min(1).describe("The content to submit"),
+    content_type: tool.schema.enum(["idea", "tip", "lore", "snippet", "feature_request"]).describe("Type of content"),
+    tags: tool.schema.array(tool.schema.string()).optional().describe("Optional tags for categorization"),
+    metadata: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional().describe("Optional metadata (e.g., code language for snippets)")
+  },
+  async execute(args) {
+    const validated = CreateMandateArgsSchema.parse(args);
+    const agentName = "system";
+    const entry = {
+      id: generateMandateId(),
+      content: validated.content,
+      content_type: validated.content_type,
+      author_agent: agentName,
+      created_at: new Date().toISOString(),
+      status: "candidate",
+      tags: validated.tags || [],
+      metadata: validated.metadata
+    };
+    const validatedEntry = MandateEntrySchema.parse(entry);
+    const storage = getMandateStorage();
+    try {
+      await storage.store(validatedEntry);
+    } catch (error45) {
+      throw new MandateError(`Failed to store mandate: ${error45 instanceof Error ? error45.message : String(error45)}`, "mandate_file", error45);
+    }
+    return JSON.stringify({
+      success: true,
+      mandate: validatedEntry,
+      message: `Mandate ${validatedEntry.id} filed successfully`
+    }, null, 2);
+  }
+});
+var mandate_vote = tool({
+  description: "Cast a vote (upvote or downvote) on an existing mandate",
+  args: {
+    mandate_id: tool.schema.string().describe("Mandate ID to vote on"),
+    vote_type: tool.schema.enum(["upvote", "downvote"]).describe("Type of vote"),
+    agent_name: tool.schema.string().describe("Agent name casting the vote")
+  },
+  async execute(args) {
+    const validated = CastVoteArgsSchema.parse({
+      mandate_id: args.mandate_id,
+      vote_type: args.vote_type,
+      weight: 1
+    });
+    const storage = getMandateStorage();
+    const mandate = await storage.get(validated.mandate_id);
+    if (!mandate) {
+      throw new MandateError(`Mandate ${validated.mandate_id} not found`, "mandate_vote");
+    }
+    const hasVoted = await storage.hasVoted(validated.mandate_id, args.agent_name);
+    if (hasVoted) {
+      throw new MandateError(`Agent ${args.agent_name} has already voted on mandate ${validated.mandate_id}`, "mandate_vote");
+    }
+    const vote = {
+      id: generateVoteId(),
+      mandate_id: validated.mandate_id,
+      agent_name: args.agent_name,
+      vote_type: validated.vote_type,
+      timestamp: new Date().toISOString(),
+      weight: validated.weight
+    };
+    const validatedVote = VoteSchema.parse(vote);
+    try {
+      await storage.vote(validatedVote);
+    } catch (error45) {
+      throw new MandateError(`Failed to cast vote: ${error45 instanceof Error ? error45.message : String(error45)}`, "mandate_vote", error45);
+    }
+    const promotion = await updateMandateStatus(validated.mandate_id, storage);
+    return JSON.stringify({
+      success: true,
+      vote: validatedVote,
+      promotion: {
+        previous_status: promotion.previous_status,
+        new_status: promotion.new_status,
+        status_changed: promotion.status_changed,
+        score: promotion.score
+      },
+      message: formatPromotionResult({
+        mandate_id: promotion.mandate_id,
+        previous_status: promotion.previous_status,
+        new_status: promotion.new_status,
+        score: promotion.score,
+        promoted: promotion.status_changed,
+        reason: evaluatePromotion(mandate, promotion.score).reason || "Vote recorded"
+      })
+    }, null, 2);
+  }
+});
+var mandate_query = tool({
+  description: "Search for relevant mandates using semantic search (by meaning, not keywords)",
+  args: {
+    query: tool.schema.string().min(1).describe("Natural language query"),
+    limit: tool.schema.number().int().positive().optional().describe("Max results to return (default: 5)"),
+    status: tool.schema.enum(["candidate", "established", "mandate", "rejected"]).optional().describe("Filter by status"),
+    content_type: tool.schema.enum(["idea", "tip", "lore", "snippet", "feature_request"]).optional().describe("Filter by content type")
+  },
+  async execute(args) {
+    const storage = getMandateStorage();
+    const limit = args.limit ?? 5;
+    try {
+      let results = await storage.find(args.query, limit * 2);
+      if (args.status) {
+        results = results.filter((m) => m.status === args.status);
+      }
+      if (args.content_type) {
+        results = results.filter((m) => m.content_type === args.content_type);
+      }
+      results = results.slice(0, limit);
+      const resultsWithScores = await Promise.all(results.map(async (mandate) => {
+        const score = await storage.calculateScore(mandate.id);
+        return { mandate, score };
+      }));
+      resultsWithScores.sort((a, b) => b.score.decayed_score - a.score.decayed_score);
+      return JSON.stringify({
+        query: args.query,
+        count: resultsWithScores.length,
+        results: resultsWithScores.map(({ mandate, score }) => ({
+          id: mandate.id,
+          content: mandate.content,
+          content_type: mandate.content_type,
+          status: mandate.status,
+          author: mandate.author_agent,
+          created_at: mandate.created_at,
+          tags: mandate.tags,
+          score: {
+            net_votes: score.net_votes,
+            vote_ratio: score.vote_ratio,
+            decayed_score: score.decayed_score
+          }
+        }))
+      }, null, 2);
+    } catch (error45) {
+      throw new MandateError(`Failed to query mandates: ${error45 instanceof Error ? error45.message : String(error45)}`, "mandate_query", error45);
+    }
+  }
+});
+var mandate_list = tool({
+  description: "List mandates with optional filters (status, content type)",
+  args: {
+    status: tool.schema.enum(["candidate", "established", "mandate", "rejected"]).optional().describe("Filter by status"),
+    content_type: tool.schema.enum(["idea", "tip", "lore", "snippet", "feature_request"]).optional().describe("Filter by content type"),
+    limit: tool.schema.number().int().positive().optional().describe("Max results to return (default: 20)")
+  },
+  async execute(args) {
+    const storage = getMandateStorage();
+    const limit = args.limit ?? 20;
+    try {
+      let results = await storage.list({
+        status: args.status,
+        content_type: args.content_type
+      });
+      results = results.slice(0, limit);
+      const resultsWithScores = await Promise.all(results.map(async (mandate) => {
+        const score = await storage.calculateScore(mandate.id);
+        return { mandate, score };
+      }));
+      resultsWithScores.sort((a, b) => b.score.decayed_score - a.score.decayed_score);
+      return JSON.stringify({
+        filters: {
+          status: args.status || "all",
+          content_type: args.content_type || "all"
+        },
+        count: resultsWithScores.length,
+        results: resultsWithScores.map(({ mandate, score }) => ({
+          id: mandate.id,
+          content: mandate.content.slice(0, 200),
+          content_type: mandate.content_type,
+          status: mandate.status,
+          author: mandate.author_agent,
+          created_at: mandate.created_at,
+          tags: mandate.tags,
+          score: {
+            net_votes: score.net_votes,
+            vote_ratio: score.vote_ratio,
+            decayed_score: score.decayed_score
+          }
+        }))
+      }, null, 2);
+    } catch (error45) {
+      throw new MandateError(`Failed to list mandates: ${error45 instanceof Error ? error45.message : String(error45)}`, "mandate_list", error45);
+    }
+  }
+});
+var mandate_stats = tool({
+  description: "Get voting statistics for a specific mandate or overall system",
+  args: {
+    mandate_id: tool.schema.string().optional().describe("Mandate ID (omit for overall stats)")
+  },
+  async execute(args) {
+    const storage = getMandateStorage();
+    try {
+      if (args.mandate_id) {
+        const mandate = await storage.get(args.mandate_id);
+        if (!mandate) {
+          throw new MandateError(`Mandate ${args.mandate_id} not found`, "mandate_stats");
+        }
+        const score = await storage.calculateScore(args.mandate_id);
+        const votes = await storage.getVotes(args.mandate_id);
+        return JSON.stringify({
+          mandate_id: args.mandate_id,
+          status: mandate.status,
+          content_type: mandate.content_type,
+          author: mandate.author_agent,
+          created_at: mandate.created_at,
+          votes: {
+            total: votes.length,
+            raw_upvotes: score.raw_upvotes,
+            raw_downvotes: score.raw_downvotes,
+            decayed_upvotes: score.decayed_upvotes,
+            decayed_downvotes: score.decayed_downvotes,
+            net_votes: score.net_votes,
+            vote_ratio: score.vote_ratio,
+            decayed_score: score.decayed_score
+          },
+          voters: votes.map((v) => ({
+            agent: v.agent_name,
+            vote_type: v.vote_type,
+            timestamp: v.timestamp
+          }))
+        }, null, 2);
+      } else {
+        const allMandates = await storage.list();
+        const stats = {
+          total_mandates: allMandates.length,
+          by_status: {
+            candidate: 0,
+            established: 0,
+            mandate: 0,
+            rejected: 0
+          },
+          by_content_type: {
+            idea: 0,
+            tip: 0,
+            lore: 0,
+            snippet: 0,
+            feature_request: 0
+          },
+          total_votes: 0
+        };
+        for (const mandate of allMandates) {
+          stats.by_status[mandate.status]++;
+          stats.by_content_type[mandate.content_type]++;
+          const votes = await storage.getVotes(mandate.id);
+          stats.total_votes += votes.length;
+        }
+        return JSON.stringify(stats, null, 2);
+      }
+    } catch (error45) {
+      if (error45 instanceof MandateError) {
+        throw error45;
+      }
+      throw new MandateError(`Failed to get mandate stats: ${error45 instanceof Error ? error45.message : String(error45)}`, "mandate_stats", error45);
+    }
+  }
+});
+var mandateTools = {
+  mandate_file,
+  mandate_vote,
+  mandate_query,
+  mandate_list,
+  mandate_stats
+};
 // src/anti-patterns.ts
 init_zod();
 var PatternKindSchema = exports_external.enum(["pattern", "anti_pattern"]);
@@ -34828,21 +36087,21 @@ class InMemoryMaturityStorage {
 }
 
 // src/storage.ts
-var cachedCommand = null;
-async function resolveSemanticMemoryCommand() {
-  if (cachedCommand)
-    return cachedCommand;
+var cachedCommand2 = null;
+async function resolveSemanticMemoryCommand2() {
+  if (cachedCommand2)
+    return cachedCommand2;
   const nativeResult = await Bun.$`which semantic-memory`.quiet().nothrow();
   if (nativeResult.exitCode === 0) {
-    cachedCommand = ["semantic-memory"];
-    return cachedCommand;
+    cachedCommand2 = ["semantic-memory"];
+    return cachedCommand2;
   }
-  cachedCommand = ["bunx", "semantic-memory"];
-  return cachedCommand;
+  cachedCommand2 = ["bunx", "semantic-memory"];
+  return cachedCommand2;
 }
-async function execSemanticMemory(args) {
+async function execSemanticMemory2(args) {
   try {
-    const cmd = await resolveSemanticMemoryCommand();
+    const cmd = await resolveSemanticMemoryCommand2();
     const fullCmd = [...cmd, ...args];
     const proc = Bun.spawn(fullCmd, {
       stdout: "pipe",
@@ -34886,7 +36145,7 @@ class SemanticMemoryStorage {
     if (metadata) {
       args.push("--metadata", JSON.stringify(metadata));
     }
-    await execSemanticMemory(args);
+    await execSemanticMemory2(args);
   }
   async find(collection, query, limit = 10, useFts = false) {
     const args = [
@@ -34901,7 +36160,7 @@ class SemanticMemoryStorage {
     if (useFts) {
       args.push("--fts");
     }
-    const result = await execSemanticMemory(args);
+    const result = await execSemanticMemory2(args);
     if (result.exitCode !== 0) {
       console.warn(`[storage] semantic-memory find() failed with exit code ${result.exitCode}: ${result.stderr.toString().trim()}`);
       return [];
@@ -34926,7 +36185,7 @@ class SemanticMemoryStorage {
     }
   }
   async list(collection) {
-    const result = await execSemanticMemory([
+    const result = await execSemanticMemory2([
       "list",
       "--collection",
       collection,
@@ -35111,7 +36370,7 @@ function createStorage(config2 = {}) {
 }
 async function isSemanticMemoryAvailable() {
   try {
-    const result = await execSemanticMemory(["stats"]);
+    const result = await execSemanticMemory2(["stats"]);
     return result.exitCode === 0;
   } catch {
     return false;
@@ -35196,7 +36455,8 @@ var SwarmPlugin = async (input) => {
       ...structuredTools,
       ...swarmTools,
       ...repoCrawlTools,
-      ...skillsTools
+      ...skillsTools,
+      ...mandateTools
     },
     event: async ({ event }) => {
       if (event.type === "session.idle") {
@@ -35243,27 +36503,35 @@ var allTools = {
   ...structuredTools,
   ...swarmTools,
   ...repoCrawlTools,
-  ...skillsTools
+  ...skillsTools,
+  ...mandateTools
 };
 export {
   withToolFallback,
   warnMissingTool,
+  updateMandateStatus,
+  updateAllMandateStatuses,
   swarmTools,
   swarmMailTools,
   structuredTools,
   skillsTools,
+  shouldPromote,
   setSwarmMailProjectDirectory,
   setStorage,
   setSkillsProjectDirectory,
+  setMandateStorage,
   setBeadsWorkingDirectory,
   setAgentMailProjectDirectory,
   selectStrategy,
   resetToolCache,
   resetStorage,
+  resetMandateStorage,
   requireTool,
   repoCrawlTools,
   parseFrontmatter,
   mcpCallWithAutoInit,
+  mandateTools,
+  mandateSchemas,
   listSkills,
   isToolAvailable,
   isSemanticMemoryAvailable,
@@ -35271,12 +36539,15 @@ export {
   isAgentNotFoundError,
   invalidateSkillsCache,
   ifToolAvailable,
+  groupByTransition,
   getToolAvailability,
   getSwarmMailProjectDirectory,
   getStorage,
+  getStatusChanges,
   getSkillsContextForSwarm,
   getSkill,
   getSchemaByName,
+  getMandateStorage,
   getBeadsWorkingDirectory,
   getAgentMailProjectDirectory,
   formatZodErrors,
@@ -35284,13 +36555,17 @@ export {
   formatSubtaskPromptV2,
   formatSubtaskPrompt,
   formatStrategyGuidelines,
+  formatPromotionResult,
   formatEvaluationPrompt,
   findRelevantSkills,
   extractJsonFromText,
+  evaluatePromotion,
+  evaluateBatchPromotions,
   discoverSkills,
   src_default as default,
   createStorageWithFallback,
   createStorage,
+  createMandateStorage,
   createAgentMailError,
   clearSessionState,
   checkTool,
@@ -35309,6 +36584,8 @@ export {
   agentMailTools,
   WeightedEvaluationSchema,
   WeightedCriterionEvaluationSchema,
+  VoteTypeSchema,
+  VoteSchema,
   ValidationResultSchema,
   TaskDecompositionSchema,
   SwarmStatusSchema,
@@ -35320,10 +36597,19 @@ export {
   SubtaskDependencySchema,
   SpawnedAgentSchema,
   SemanticMemoryStorage,
+  SemanticMemoryMandateStorage,
+  ScoreCalculationResultSchema,
   SUBTASK_PROMPT_V2,
   STRATEGIES,
   RepoCrawlError,
+  QueryMandatesArgsSchema,
+  MandateStatusSchema,
+  MandateScoreSchema,
+  MandateError,
+  MandateEntrySchema,
+  MandateContentTypeSchema,
   InMemoryStorage,
+  InMemoryMandateStorage,
   FileReservationConflictError,
   EvaluationSchema,
   EvaluationRequestSchema,
@@ -35335,8 +36621,12 @@ export {
   DecomposedSubtaskSchema,
   DecomposeArgsSchema,
   DEFAULT_STORAGE_CONFIG,
+  DEFAULT_MANDATE_STORAGE_CONFIG,
+  DEFAULT_MANDATE_DECAY_CONFIG,
   DEFAULT_CRITERIA,
   CriterionEvaluationSchema,
+  CreateMandateArgsSchema,
+  CastVoteArgsSchema,
   BeadValidationError,
   BeadUpdateArgsSchema,
   BeadTypeSchema,