opencode-swarm-plugin 0.15.0 → 0.16.0

package/dist/plugin.js

@@ -29668,6 +29668,84 @@ 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()
+});
 // src/beads.ts
 var beadsWorkingDirectory = null;
 function setBeadsWorkingDirectory(directory) {
@@ -34993,6 +35071,716 @@ 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
+  };
+}
+var globalMandateStorage = null;
+function getMandateStorage() {
+  if (!globalMandateStorage) {
+    globalMandateStorage = createMandateStorage();
+  }
+  return globalMandateStorage;
+}
+
+// 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}`;
+}
+
+// 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"]);
@@ -35128,7 +35916,8 @@ var SwarmPlugin = async (input) => {
       ...structuredTools,
       ...swarmTools,
       ...repoCrawlTools,
-      ...skillsTools
+      ...skillsTools,
+      ...mandateTools
     },
     event: async ({ event }) => {
       if (event.type === "session.idle") {
@@ -35174,7 +35963,8 @@ var allTools = {
   ...structuredTools,
   ...swarmTools,
   ...repoCrawlTools,
-  ...skillsTools
+  ...skillsTools,
+  ...mandateTools
 };
 export {
   SwarmPlugin