opencode-swarm-plugin 0.15.0 → 0.17.0

package/dist/index.js

@@ -29668,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) {
@@ -29751,7 +29841,7 @@ function parseBead(output) {
     const parsed = JSON.parse(output);
     const data = Array.isArray(parsed) ? parsed[0] : parsed;
     if (!data) {
-      throw new BeadError("No bead data in response", "parse");
+      throw new BeadError("No bead data in response. The bd CLI may not be installed or returned unexpected output. Try: Run 'bd --version' to verify installation, or check if .beads/ directory exists in project.", "parse");
     }
     return BeadSchema.parse(data);
   } catch (error45) {
@@ -29761,7 +29851,7 @@ function parseBead(output) {
     if (error45 instanceof BeadError) {
       throw error45;
     }
-    throw new BeadError(`Failed to parse bead JSON: ${output}`, "parse");
+    throw new BeadError(`Failed to parse bead JSON because output is malformed. Try: Check if bd CLI is up to date with 'bd --version' (need v1.0.0+), or inspect output: ${output.slice(0, 100)}`, "parse");
   }
 }
 function parseBeads(output) {
@@ -29772,7 +29862,7 @@ function parseBeads(output) {
     if (error45 instanceof exports_external.ZodError) {
       throw new BeadValidationError(`Invalid beads data: ${error45.message}`, error45);
     }
-    throw new BeadError(`Failed to parse beads JSON: ${output}`, "parse");
+    throw new BeadError(`Failed to parse beads JSON because output is malformed. Try: Check if bd CLI is up to date with 'bd --version' (need v1.0.0+), or inspect output: ${output.slice(0, 100)}`, "parse");
   }
 }
 var beads_create = tool({
@@ -29789,14 +29879,14 @@ var beads_create = tool({
     const cmdParts = buildCreateCommand(validated);
     const result = await runBdCommand(cmdParts.slice(1));
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to create bead: ${result.stderr}`, cmdParts.join(" "), result.exitCode, result.stderr);
+      throw new BeadError(`Failed to create bead because bd command exited with code ${result.exitCode}. Error: ${result.stderr}. Try: Check if beads initialized with 'bd init' in project root, or verify .beads/ directory exists.`, cmdParts.join(" "), result.exitCode, result.stderr);
     }
     const stdout = result.stdout.trim();
     if (!stdout) {
-      throw new BeadError("bd create returned empty output", cmdParts.join(" "), 0, "Empty stdout");
+      throw new BeadError("bd create returned empty output because command produced no response. Try: Check if bd is properly installed with 'bd --version', or run 'bd list' to test basic functionality.", cmdParts.join(" "), 0, "Empty stdout");
     }
     if (stdout.startsWith("error:") || stdout.startsWith("Error:")) {
-      throw new BeadError(`bd create failed: ${stdout}`, cmdParts.join(" "), 0, stdout);
+      throw new BeadError(`bd create failed because command returned error in stdout: ${stdout}. Try: Check error message above, verify beads initialized with 'bd init', or check .beads/issues.jsonl for corruption.`, cmdParts.join(" "), 0, stdout);
     }
     const bead = parseBead(stdout);
     return JSON.stringify(bead, null, 2);
@@ -29828,7 +29918,7 @@ var beads_create_epic = tool({
       });
       const epicResult = await runBdCommand(epicCmd.slice(1));
       if (epicResult.exitCode !== 0) {
-        throw new BeadError(`Failed to create epic: ${epicResult.stderr}`, epicCmd.join(" "), epicResult.exitCode);
+        throw new BeadError(`Failed to create epic because bd command failed: ${epicResult.stderr}. Try: Verify beads initialized with 'bd init', check if .beads/ directory is writable, or run 'bd list' to test basic functionality.`, epicCmd.join(" "), epicResult.exitCode);
       }
       const epic = parseBead(epicResult.stdout);
       created.push(epic);
@@ -29846,7 +29936,7 @@ var beads_create_epic = tool({
         });
         const subtaskResult = await runBdCommand(subtaskCmd.slice(1));
         if (subtaskResult.exitCode !== 0) {
-          throw new BeadError(`Failed to create subtask: ${subtaskResult.stderr}`, subtaskCmd.join(" "), subtaskResult.exitCode);
+          throw new BeadError(`Failed to create subtask because bd command failed: ${subtaskResult.stderr}. Try: Check if parent epic exists with 'bd show ${epic.id}', verify .beads/issues.jsonl is not corrupted, or check for invalid characters in title.`, subtaskCmd.join(" "), subtaskResult.exitCode);
         }
         const subtaskBead = parseBead(subtaskResult.stdout);
         created.push(subtaskBead);
@@ -29902,7 +29992,7 @@ ${rollbackErrors.join(`
 
 No beads to rollback.`;
       }
-      throw new BeadError(`Epic creation failed: ${errorMsg}${rollbackInfo}`, "beads_create_epic", 1);
+      throw new BeadError(`Epic creation failed: ${errorMsg}${rollbackInfo}. Try: If rollback failed, manually close beads with 'bd close <id> --reason "Rollback"', check .beads/issues.jsonl for partial state, or re-run beads_create_epic with corrected parameters.`, "beads_create_epic", 1);
     }
   }
 });
@@ -29930,7 +30020,7 @@ var beads_query = tool({
     }
     const result = await runBdCommand(cmd.slice(1));
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to query beads: ${result.stderr}`, cmd.join(" "), result.exitCode);
+      throw new BeadError(`Failed to query beads because bd command failed: ${result.stderr}. Try: Check if beads initialized with 'bd init', verify .beads/ directory exists, or run 'bd --version' to check CLI version.`, cmd.join(" "), result.exitCode);
     }
     const beads = parseBeads(result.stdout);
     const limited = beads.slice(0, validated.limit);
@@ -29960,7 +30050,7 @@ var beads_update = tool({
     cmd.push("--json");
     const result = await runBdCommand(cmd.slice(1));
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to update bead: ${result.stderr}`, cmd.join(" "), result.exitCode);
+      throw new BeadError(`Failed to update bead because bd command failed: ${result.stderr}. Try: Verify bead exists with 'bd show ${validated.id}', check for invalid status values, or inspect .beads/issues.jsonl for corruption.`, cmd.join(" "), result.exitCode);
     }
     const bead = parseBead(result.stdout);
     return JSON.stringify(bead, null, 2);
@@ -29984,7 +30074,7 @@ var beads_close = tool({
     ];
     const result = await runBdCommand(cmd.slice(1));
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to close bead: ${result.stderr}`, cmd.join(" "), result.exitCode);
+      throw new BeadError(`Failed to close bead because bd command failed: ${result.stderr}. Try: Verify bead exists and is not already closed with 'beads_query(status="closed")' or 'bd show ${validated.id}', check if bead ID is correct.`, cmd.join(" "), result.exitCode);
     }
     const bead = parseBead(result.stdout);
     return `Closed ${bead.id}: ${validated.reason}`;
@@ -30004,7 +30094,7 @@ var beads_start = tool({
       "--json"
     ]);
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to start bead: ${result.stderr}`, `bd update ${args.id} --status in_progress --json`, result.exitCode);
+      throw new BeadError(`Failed to start bead because bd update command failed: ${result.stderr}. Try: Verify bead exists with 'bd show ${args.id}', check if already in_progress with 'beads_query(status="in_progress")', or use beads_update directly.`, `bd update ${args.id} --status in_progress --json`, result.exitCode);
     }
     const bead = parseBead(result.stdout);
     return `Started: ${bead.id}`;
@@ -30016,7 +30106,7 @@ var beads_ready = tool({
   async execute(args, ctx) {
     const result = await runBdCommand(["ready", "--json"]);
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to get ready beads: ${result.stderr}`, "bd ready --json", result.exitCode);
+      throw new BeadError(`Failed to get ready beads because bd ready command failed: ${result.stderr}. Try: Check if beads initialized with 'bd init', verify .beads/ directory is readable, or run 'bd list --json' to test basic query.`, "bd ready --json", result.exitCode);
     }
     const beads = parseBeads(result.stdout);
     if (beads.length === 0) {
@@ -30049,7 +30139,7 @@ var beads_sync = tool({
     };
     const flushResult = await withTimeout(runBdCommand(["sync", "--flush-only"]), TIMEOUT_MS, "bd sync --flush-only");
     if (flushResult.exitCode !== 0) {
-      throw new BeadError(`Failed to flush beads: ${flushResult.stderr}`, "bd sync --flush-only", flushResult.exitCode);
+      throw new BeadError(`Failed to flush beads because bd sync failed: ${flushResult.stderr}. Try: Check if .beads/ directory is writable, verify no corrupted JSONL files, or run 'bd list' to test basic beads functionality.`, "bd sync --flush-only", flushResult.exitCode);
     }
     const beadsStatusResult = await runGitCommand([
       "status",
@@ -30060,11 +30150,11 @@ var beads_sync = tool({
     if (hasChanges) {
       const addResult = await runGitCommand(["add", ".beads/"]);
       if (addResult.exitCode !== 0) {
-        throw new BeadError(`Failed to stage beads: ${addResult.stderr}`, "git add .beads/", addResult.exitCode);
+        throw new BeadError(`Failed to stage beads because git add failed: ${addResult.stderr}. Try: Check if .beads/ directory exists, verify git is initialized with 'git status', or check for .gitignore patterns blocking .beads/.`, "git add .beads/", addResult.exitCode);
       }
       const commitResult = await withTimeout(runGitCommand(["commit", "-m", "chore: sync beads"]), TIMEOUT_MS, "git commit");
       if (commitResult.exitCode !== 0 && !commitResult.stdout.includes("nothing to commit")) {
-        throw new BeadError(`Failed to commit beads: ${commitResult.stderr}`, "git commit", commitResult.exitCode);
+        throw new BeadError(`Failed to commit beads because git commit failed: ${commitResult.stderr}. Try: Check git config (user.name, user.email) with 'git config --list', verify working tree is clean, or check for pre-commit hooks blocking commit.`, "git commit", commitResult.exitCode);
       }
     }
     if (autoPull) {
@@ -30103,7 +30193,7 @@ var beads_sync = tool({
         }
       }
       if (pullResult.exitCode !== 0) {
-        throw new BeadError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
+        throw new BeadError(`Failed to pull because git pull --rebase failed: ${pullResult.stderr}. Try: Resolve merge conflicts manually with 'git status', check if remote is accessible with 'git remote -v', or use skip_verification to bypass automatic pull.`, "git pull --rebase", pullResult.exitCode);
       }
       const importResult = await withTimeout(runBdCommand(["sync", "--import-only"]), TIMEOUT_MS, "bd sync --import-only");
       if (importResult.exitCode !== 0) {
@@ -30112,7 +30202,7 @@ var beads_sync = tool({
     }
     const pushResult = await withTimeout(runGitCommand(["push"]), TIMEOUT_MS, "git push");
     if (pushResult.exitCode !== 0) {
-      throw new BeadError(`Failed to push: ${pushResult.stderr}`, "git push", pushResult.exitCode);
+      throw new BeadError(`Failed to push because git push failed: ${pushResult.stderr}. Try: Check if remote branch is up to date with 'git pull --rebase', verify push permissions, check remote URL with 'git remote -v', or force push with 'git push --force-with-lease' if safe.`, "git push", pushResult.exitCode);
     }
     const statusResult = await runGitCommand(["status", "--porcelain"]);
     const status = statusResult.stdout.trim();
@@ -30132,7 +30222,7 @@ var beads_link_thread = tool({
   async execute(args, ctx) {
     const queryResult = await runBdCommand(["show", args.bead_id, "--json"]);
     if (queryResult.exitCode !== 0) {
-      throw new BeadError(`Failed to get bead: ${queryResult.stderr}`, `bd show ${args.bead_id} --json`, queryResult.exitCode);
+      throw new BeadError(`Failed to get bead because bd show command failed: ${queryResult.stderr}. Try: Verify bead ID is correct with 'beads_query()', check if bead exists with 'bd list --json', or check .beads/issues.jsonl for valid entries.`, `bd show ${args.bead_id} --json`, queryResult.exitCode);
     }
     const bead = parseBead(queryResult.stdout);
     const existingDesc = bead.description || "";
@@ -30151,7 +30241,7 @@ ${threadMarker}` : threadMarker;
       "--json"
     ]);
     if (updateResult.exitCode !== 0) {
-      throw new BeadError(`Failed to update bead: ${updateResult.stderr}`, `bd update ${args.bead_id} -d ...`, updateResult.exitCode);
+      throw new BeadError(`Failed to update bead because bd update command failed: ${updateResult.stderr}. Try: Verify bead exists with 'bd show ${args.bead_id}', check for invalid characters in description, or inspect .beads/issues.jsonl for corruption.`, `bd update ${args.bead_id} -d ...`, updateResult.exitCode);
     }
     return `Linked bead ${args.bead_id} to thread ${args.thread_id}`;
   }
@@ -33925,7 +34015,7 @@ async function runVerificationGate(filesTouched, skipUbs = false) {
       };
       if (!ubsStep.passed) {
         ubsStep.error = `Found ${ubsResult.summary.critical} critical bugs`;
-        blockers.push(`UBS: ${ubsResult.summary.critical} critical bugs found`);
+        blockers.push(`UBS found ${ubsResult.summary.critical} critical bug(s). Try: Run 'ubs scan ${filesTouched.join(" ")}' to see details, fix critical bugs in reported files, or use skip_ubs_scan=true to bypass (not recommended).`);
       }
       steps.push(ubsStep);
     } else {
@@ -33942,12 +34032,12 @@ async function runVerificationGate(filesTouched, skipUbs = false) {
   const typecheckStep = await runTypecheckVerification();
   steps.push(typecheckStep);
   if (!typecheckStep.passed && !typecheckStep.skipped) {
-    blockers.push(`Typecheck: ${typecheckStep.error?.slice(0, 100) || "failed"}`);
+    blockers.push(`Typecheck failed: ${typecheckStep.error?.slice(0, 100) || "type errors found"}. Try: Run 'tsc --noEmit' to see full errors, check tsconfig.json configuration, or fix reported type errors in modified files.`);
   }
   const testStep = await runTestVerification(filesTouched);
   steps.push(testStep);
   if (!testStep.passed && !testStep.skipped) {
-    blockers.push(`Tests: ${testStep.error?.slice(0, 100) || "failed"}`);
+    blockers.push(`Tests failed: ${testStep.error?.slice(0, 100) || "test failures"}. Try: Run 'bun test ${testStep.command.split(" ").slice(2).join(" ")}' to see full output, check test assertions, or fix failing tests in modified files.`);
   }
   const passedCount = steps.filter((s) => s.passed).length;
   const skippedCount = steps.filter((s) => s.skipped).length;
@@ -34002,8 +34092,8 @@ async function runUbsScan(files) {
         }
       };
     } catch (error45) {
-      console.error(`[swarm] CRITICAL: UBS scan failed to parse JSON output:`, error45);
-      console.error(`[swarm] Raw output:`, output);
+      console.error(`[swarm] CRITICAL: UBS scan failed to parse JSON output because output is malformed:`, error45);
+      console.error(`[swarm] Raw output: ${output}. Try: Run 'ubs doctor' to check installation, verify UBS version with 'ubs --version' (need v1.0.0+), or check if UBS supports --json flag.`);
       return {
         exitCode: result.exitCode,
         bugs: [],
@@ -34093,7 +34183,7 @@ var swarm_complete = tool({
               error: s.error?.slice(0, 200)
             }))
           },
-          hint: "Fix the failing checks and try again. Use skip_verification=true only as last resort.",
+          hint: verificationResult.blockers.length > 0 ? `Fix these issues: ${verificationResult.blockers.map((b, i) => `${i + 1}. ${b}`).join(", ")}. Use skip_verification=true only as last resort.` : "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);
       }
@@ -34104,12 +34194,12 @@ var swarm_complete = tool({
       if (ubsResult && ubsResult.summary.critical > 0) {
         return JSON.stringify({
           success: false,
-          error: "UBS found critical bugs - fix before completing",
+          error: `UBS found ${ubsResult.summary.critical} critical bug(s) that must be fixed before completing`,
           ubs_scan: {
             critical_count: ubsResult.summary.critical,
             bugs: ubsResult.bugs.filter((b) => b.severity === "critical")
           },
-          hint: "Fix the critical bugs and try again, or use skip_ubs_scan=true to bypass"
+          hint: `Fix these critical bugs: ${ubsResult.bugs.filter((b) => b.severity === "critical").map((b) => `${b.file}:${b.line} - ${b.message}`).slice(0, 3).join("; ")}. Try: Run 'ubs scan ${args.files_touched?.join(" ") || "."} --json' for full report, fix reported issues, or use skip_ubs_scan=true to bypass (not recommended).`
         }, null, 2);
       }
     }
@@ -34135,7 +34225,7 @@ var swarm_complete = tool({
     }
     const closeResult = await Bun.$`bd close ${args.bead_id} --reason ${args.summary} --json`.quiet().nothrow();
     if (closeResult.exitCode !== 0) {
-      throw new SwarmError(`Failed to close bead: ${closeResult.stderr.toString()}`, "complete");
+      throw new SwarmError(`Failed to close bead because bd close command failed: ${closeResult.stderr.toString()}. Try: Verify bead exists and is not already closed with 'bd show ${args.bead_id}', check if bead ID is correct with 'beads_query()', or use beads_close tool directly.`, "complete");
     }
     try {
       await releaseSwarmFiles({
@@ -35150,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. Use list() to see available mandates.`);
+    }
+    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}'. Each agent can vote once per mandate to ensure fair consensus.`);
+    }
+    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. Use list() to see available mandates.`);
+    }
+    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}'. Each agent can vote once per mandate to ensure fair consensus.`);
+    }
+    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}'. Valid backends are 'semantic-memory' or 'memory'.`);
+  }
+}
+async function updateMandateStatus(mandateId, storage) {
+  const entry = await storage.get(mandateId);
+  if (!entry) {
+    throw new Error(`Mandate '${mandateId}' not found when calculating score. Use storage.list() to verify the mandate exists.`);
+  }
+  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. Use mandate_list() to see available mandates, or check the ID is correct.`, "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}'. Each agent can vote once per mandate. This is expected behavior to prevent vote manipulation.`, "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. Use mandate_list() to see available mandates, or check the ID is correct.`, "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"]);
@@ -35241,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",
@@ -35299,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 = [
@@ -35314,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 [];
@@ -35339,7 +36185,7 @@ class SemanticMemoryStorage {
     }
   }
   async list(collection) {
-    const result = await execSemanticMemory([
+    const result = await execSemanticMemory2([
       "list",
       "--collection",
       collection,
@@ -35524,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;
@@ -35609,7 +36455,8 @@ var SwarmPlugin = async (input) => {
       ...structuredTools,
       ...swarmTools,
       ...repoCrawlTools,
-      ...skillsTools
+      ...skillsTools,
+      ...mandateTools
     },
     event: async ({ event }) => {
       if (event.type === "session.idle") {
@@ -35656,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,
@@ -35684,12 +36539,15 @@ export {
   isAgentNotFoundError,
   invalidateSkillsCache,
   ifToolAvailable,
+  groupByTransition,
   getToolAvailability,
   getSwarmMailProjectDirectory,
   getStorage,
+  getStatusChanges,
   getSkillsContextForSwarm,
   getSkill,
   getSchemaByName,
+  getMandateStorage,
   getBeadsWorkingDirectory,
   getAgentMailProjectDirectory,
   formatZodErrors,
@@ -35697,13 +36555,17 @@ export {
   formatSubtaskPromptV2,
   formatSubtaskPrompt,
   formatStrategyGuidelines,
+  formatPromotionResult,
   formatEvaluationPrompt,
   findRelevantSkills,
   extractJsonFromText,
+  evaluatePromotion,
+  evaluateBatchPromotions,
   discoverSkills,
   src_default as default,
   createStorageWithFallback,
   createStorage,
+  createMandateStorage,
   createAgentMailError,
   clearSessionState,
   checkTool,
@@ -35722,6 +36584,8 @@ export {
   agentMailTools,
   WeightedEvaluationSchema,
   WeightedCriterionEvaluationSchema,
+  VoteTypeSchema,
+  VoteSchema,
   ValidationResultSchema,
   TaskDecompositionSchema,
   SwarmStatusSchema,
@@ -35733,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,
@@ -35748,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,