opencode-swarm-plugin 0.15.0 → 0.16.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) {
@@ -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`);
+    }
+    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"]);
@@ -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,