opencode-swarm-plugin 0.21.0 → 0.23.0

package/dist/schemas/evaluation.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Evaluation schemas for structured agent output validation
+ *
+ * These schemas define the expected format for agent self-evaluations
+ * and coordinator evaluations of completed work.
+ *
+ * Includes support for confidence decay - criteria weights fade over time
+ * unless revalidated by successful outcomes.
+ *
+ * @see src/learning.ts for decay calculations
+ */
+import { z } from "zod";
+/**
+ * Evaluation of a single criterion.
+ *
+ * @example
+ * // Passing criterion
+ * { passed: true, feedback: "All types validated", score: 0.95 }
+ *
+ * @example
+ * // Failing criterion
+ * { passed: false, feedback: "Missing error handling in auth flow", score: 0.3 }
+ */
+export declare const CriterionEvaluationSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    feedback: z.ZodString;
+    score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CriterionEvaluation = z.infer<typeof CriterionEvaluationSchema>;
+/**
+ * Weighted criterion evaluation with confidence decay
+ *
+ * Extends CriterionEvaluation with weight information from learning.
+ * Lower weights indicate criteria that have been historically unreliable.
+ */
+export declare const WeightedCriterionEvaluationSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    feedback: z.ZodString;
+    score: z.ZodOptional<z.ZodNumber>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    weighted_score: z.ZodOptional<z.ZodNumber>;
+    deprecated: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type WeightedCriterionEvaluation = z.infer<typeof WeightedCriterionEvaluationSchema>;
+/**
+ * Full evaluation result
+ *
+ * Returned by agents after completing a subtask.
+ * Used by coordinator to determine if work is acceptable.
+ */
+export declare const EvaluationSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    criteria: z.ZodRecord<z.ZodString, z.ZodObject<{
+        passed: z.ZodBoolean;
+        feedback: z.ZodString;
+        score: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    overall_feedback: z.ZodString;
+    retry_suggestion: z.ZodNullable<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Evaluation = z.infer<typeof EvaluationSchema>;
+/**
+ * Default evaluation criteria
+ *
+ * These are the standard criteria used when none are specified.
+ * Can be overridden per-task or per-project.
+ */
+export declare const DEFAULT_CRITERIA: readonly ["type_safe", "no_bugs", "patterns", "readable"];
+export type DefaultCriterion = (typeof DEFAULT_CRITERIA)[number];
+/**
+ * Evaluation request arguments
+ */
+export declare const EvaluationRequestSchema: z.ZodObject<{
+    bead_id: z.ZodString;
+    subtask_title: z.ZodString;
+    files_touched: z.ZodArray<z.ZodString>;
+    requested_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EvaluationRequest = z.infer<typeof EvaluationRequestSchema>;
+/**
+ * Weighted evaluation result with confidence-adjusted scores
+ *
+ * Used when applying learned weights to evaluation criteria.
+ */
+export declare const WeightedEvaluationSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    criteria: z.ZodRecord<z.ZodString, z.ZodObject<{
+        passed: z.ZodBoolean;
+        feedback: z.ZodString;
+        score: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        weighted_score: z.ZodOptional<z.ZodNumber>;
+        deprecated: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    overall_feedback: z.ZodString;
+    retry_suggestion: z.ZodNullable<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    average_weight: z.ZodOptional<z.ZodNumber>;
+    raw_score: z.ZodOptional<z.ZodNumber>;
+    weighted_score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WeightedEvaluation = z.infer<typeof WeightedEvaluationSchema>;
+/**
+ * Aggregated evaluation results for a swarm
+ */
+export declare const SwarmEvaluationResultSchema: z.ZodObject<{
+    epic_id: z.ZodString;
+    total: z.ZodNumber;
+    passed: z.ZodNumber;
+    failed: z.ZodNumber;
+    evaluations: z.ZodArray<z.ZodObject<{
+        bead_id: z.ZodString;
+        evaluation: z.ZodObject<{
+            passed: z.ZodBoolean;
+            criteria: z.ZodRecord<z.ZodString, z.ZodObject<{
+                passed: z.ZodBoolean;
+                feedback: z.ZodString;
+                score: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            overall_feedback: z.ZodString;
+            retry_suggestion: z.ZodNullable<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    overall_passed: z.ZodBoolean;
+    retry_needed: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SwarmEvaluationResult = z.infer<typeof SwarmEvaluationResultSchema>;
+/**
+ * Validation result with retry info
+ */
+export declare const ValidationResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodUnknown>;
+    attempts: z.ZodNumber;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    extractionMethod: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ValidationResult = z.infer<typeof ValidationResultSchema>;
+/**
+ * Failure mode taxonomy for task failures
+ *
+ * Classifies WHY tasks fail, not just that they failed.
+ * Used in outcome tracking to learn from failure patterns.
+ *
+ * @see src/learning.ts OutcomeSignalsSchema
+ * @see "Patterns for Building AI Agents" p.46
+ */
+export declare const FailureModeSchema: z.ZodEnum<{
+    timeout: "timeout";
+    unknown: "unknown";
+    conflict: "conflict";
+    validation: "validation";
+    tool_failure: "tool_failure";
+    context_overflow: "context_overflow";
+    dependency_blocked: "dependency_blocked";
+    user_cancelled: "user_cancelled";
+}>;
+export type FailureMode = z.infer<typeof FailureModeSchema>;
+//# sourceMappingURL=evaluation.d.ts.map

package/dist/schemas/evaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation.d.ts","sourceRoot":"","sources":["../../src/schemas/evaluation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;;;;;iBAY1C,CAAC;AACL,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;iBAM3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,2DAKnB,CAAC;AACX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;iBAMlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBAYnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;iBAatC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;iBAMjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;EAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/schemas/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Schema Definitions - Central export point for all Zod schemas
+ *
+ * This module re-exports all schema definitions used throughout the plugin.
+ * Schemas are organized by domain:
+ *
+ * ## Bead Schemas (Issue Tracking)
+ * - `BeadSchema` - Core bead/issue definition
+ * - `BeadStatusSchema` - Status enum (open, in_progress, blocked, closed)
+ * - `BeadTypeSchema` - Type enum (bug, feature, task, epic, chore)
+ * - `SubtaskSpecSchema` - Subtask specification for epic creation
+ *
+ * ## Task Schemas (Swarm Decomposition)
+ * - `TaskDecompositionSchema` - Full task breakdown
+ * - `DecomposedSubtaskSchema` - Individual subtask definition
+ * - `BeadTreeSchema` - Epic + subtasks structure
+ *
+ * ## Evaluation Schemas (Agent Self-Assessment)
+ * - `EvaluationSchema` - Complete evaluation with criteria
+ * - `CriterionEvaluationSchema` - Single criterion result
+ *
+ * ## Progress Schemas (Swarm Coordination)
+ * - `SwarmStatusSchema` - Overall swarm progress
+ * - `AgentProgressSchema` - Individual agent status
+ * - `SpawnedAgentSchema` - Spawned agent metadata
+ *
+ * @module schemas
+ */
+export { BeadStatusSchema, BeadTypeSchema, BeadDependencySchema, BeadSchema, BeadCreateArgsSchema, BeadUpdateArgsSchema, BeadCloseArgsSchema, BeadQueryArgsSchema, SubtaskSpecSchema, BeadTreeSchema, EpicCreateArgsSchema, EpicCreateResultSchema, type BeadStatus, type BeadType, type BeadDependency, type Bead, type BeadCreateArgs, type BeadUpdateArgs, type BeadCloseArgs, type BeadQueryArgs, type SubtaskSpec, type BeadTree, type EpicCreateArgs, type EpicCreateResult, } from "./bead";
+export { CriterionEvaluationSchema, WeightedCriterionEvaluationSchema, EvaluationSchema, WeightedEvaluationSchema, EvaluationRequestSchema, SwarmEvaluationResultSchema, ValidationResultSchema, DEFAULT_CRITERIA, type CriterionEvaluation, type WeightedCriterionEvaluation, type Evaluation, type WeightedEvaluation, type EvaluationRequest, type SwarmEvaluationResult, type ValidationResult, type DefaultCriterion, } from "./evaluation";
+export { EffortLevelSchema, DependencyTypeSchema, DecomposedSubtaskSchema, SubtaskDependencySchema, TaskDecompositionSchema, DecomposeArgsSchema, SpawnedAgentSchema, SwarmSpawnResultSchema, AgentProgressSchema, SwarmStatusSchema, type EffortLevel, type DependencyType, type DecomposedSubtask, type SubtaskDependency, type TaskDecomposition, type DecomposeArgs, type SpawnedAgent, type SwarmSpawnResult, type AgentProgress, type SwarmStatus, } from "./task";
+export { MandateContentTypeSchema, MandateStatusSchema, VoteTypeSchema, MandateEntrySchema, VoteSchema, MandateScoreSchema, CreateMandateArgsSchema, CastVoteArgsSchema, QueryMandatesArgsSchema, ScoreCalculationResultSchema, DEFAULT_MANDATE_DECAY_CONFIG, mandateSchemas, type MandateContentType, type MandateStatus, type VoteType, type MandateEntry, type Vote, type MandateScore, type MandateDecayConfig, type CreateMandateArgs, type CastVoteArgs, type QueryMandatesArgs, type ScoreCalculationResult, } from "./mandate";
+export { SwarmStrategySchema, SwarmDirectivesSchema, SwarmRecoverySchema, SwarmBeadContextSchema, CreateSwarmContextArgsSchema, UpdateSwarmContextArgsSchema, QuerySwarmContextsArgsSchema, type SwarmStrategy, type SwarmDirectives, type SwarmRecovery, type SwarmBeadContext, type CreateSwarmContextArgs, type UpdateSwarmContextArgs, type QuerySwarmContextsArgs, } from "./swarm-context";
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,UAAU,EACV,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,IAAI,EACT,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,gBAAgB,GACtB,MAAM,QAAQ,CAAC;AAGhB,OAAO,EACL,yBAAyB,EACzB,iCAAiC,EACjC,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,2BAA2B,EAC3B,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACvB,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,WAAW,GACjB,MAAM,QAAQ,CAAC;AAGhB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,kBAAkB,EAClB,uBAAuB,EACvB,kBAAkB,EAClB,uBAAuB,EACvB,4BAA4B,EAC5B,4BAA4B,EAC5B,cAAc,EACd,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,IAAI,EACT,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,GAC5B,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,EACtB,4BAA4B,EAC5B,4BAA4B,EAC5B,4BAA4B,EAC5B,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,GAC5B,MAAM,iBAAiB,CAAC"}

package/dist/schemas/mandate.d.ts

@@ -0,0 +1,336 @@
+/**
+ * Mandate schemas for voting system
+ *
+ * Agents file and vote on ideas, tips, lore, snippets, and feature requests.
+ * High-consensus items become "mandates" that influence future behavior.
+ *
+ * Vote decay and scoring patterns match learning.ts (90-day half-life).
+ */
+import { z } from "zod";
+/**
+ * Content types for mandate entries
+ */
+export declare const MandateContentTypeSchema: z.ZodEnum<{
+    idea: "idea";
+    tip: "tip";
+    lore: "lore";
+    snippet: "snippet";
+    feature_request: "feature_request";
+}>;
+export type MandateContentType = z.infer<typeof MandateContentTypeSchema>;
+/**
+ * Mandate status lifecycle
+ *
+ * - candidate: New entry, collecting votes
+ * - established: Has some consensus but not enough for mandate status
+ * - mandate: High consensus (net_votes >= 5 AND vote_ratio >= 0.7)
+ * - rejected: Strong negative consensus or explicitly rejected
+ */
+export declare const MandateStatusSchema: z.ZodEnum<{
+    candidate: "candidate";
+    established: "established";
+    mandate: "mandate";
+    rejected: "rejected";
+}>;
+export type MandateStatus = z.infer<typeof MandateStatusSchema>;
+/**
+ * Vote type
+ */
+export declare const VoteTypeSchema: z.ZodEnum<{
+    upvote: "upvote";
+    downvote: "downvote";
+}>;
+export type VoteType = z.infer<typeof VoteTypeSchema>;
+/**
+ * A mandate entry represents a proposal from an agent
+ *
+ * Entries can be ideas, tips, lore, code snippets, or feature requests.
+ * Other agents vote on entries to reach consensus.
+ */
+export declare const MandateEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    content_type: z.ZodEnum<{
+        idea: "idea";
+        tip: "tip";
+        lore: "lore";
+        snippet: "snippet";
+        feature_request: "feature_request";
+    }>;
+    author_agent: z.ZodString;
+    created_at: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        candidate: "candidate";
+        established: "established";
+        mandate: "mandate";
+        rejected: "rejected";
+    }>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type MandateEntry = z.infer<typeof MandateEntrySchema>;
+/**
+ * A vote on a mandate entry
+ *
+ * Each agent can vote once per entry (upvote or downvote).
+ * Votes decay with 90-day half-life matching learning.ts patterns.
+ */
+export declare const VoteSchema: z.ZodObject<{
+    id: z.ZodString;
+    mandate_id: z.ZodString;
+    agent_name: z.ZodString;
+    vote_type: z.ZodEnum<{
+        upvote: "upvote";
+        downvote: "downvote";
+    }>;
+    timestamp: z.ZodString;
+    weight: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type Vote = z.infer<typeof VoteSchema>;
+/**
+ * Calculated score for a mandate entry
+ *
+ * Scores are recalculated periodically with decay applied.
+ * Uses same decay formula as learning.ts (90-day half-life).
+ */
+export declare const MandateScoreSchema: z.ZodObject<{
+    mandate_id: z.ZodString;
+    net_votes: z.ZodNumber;
+    vote_ratio: z.ZodNumber;
+    decayed_score: z.ZodNumber;
+    last_calculated: z.ZodString;
+    raw_upvotes: z.ZodNumber;
+    raw_downvotes: z.ZodNumber;
+    decayed_upvotes: z.ZodNumber;
+    decayed_downvotes: z.ZodNumber;
+}, z.core.$strip>;
+export type MandateScore = z.infer<typeof MandateScoreSchema>;
+/**
+ * Configuration for mandate decay calculation
+ *
+ * Matches learning.ts decay patterns.
+ */
+export interface MandateDecayConfig {
+    /** Half-life for vote decay in days */
+    halfLifeDays: number;
+    /** Net votes threshold for mandate status */
+    mandateNetVotesThreshold: number;
+    /** Vote ratio threshold for mandate status */
+    mandateVoteRatioThreshold: number;
+    /** Net votes threshold for established status */
+    establishedNetVotesThreshold: number;
+    /** Negative net votes threshold for rejected status */
+    rejectedNetVotesThreshold: number;
+}
+export declare const DEFAULT_MANDATE_DECAY_CONFIG: MandateDecayConfig;
+/**
+ * Arguments for creating a mandate entry
+ */
+export declare const CreateMandateArgsSchema: z.ZodObject<{
+    content: z.ZodString;
+    content_type: z.ZodEnum<{
+        idea: "idea";
+        tip: "tip";
+        lore: "lore";
+        snippet: "snippet";
+        feature_request: "feature_request";
+    }>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type CreateMandateArgs = z.infer<typeof CreateMandateArgsSchema>;
+/**
+ * Arguments for casting a vote
+ */
+export declare const CastVoteArgsSchema: z.ZodObject<{
+    mandate_id: z.ZodString;
+    vote_type: z.ZodEnum<{
+        upvote: "upvote";
+        downvote: "downvote";
+    }>;
+    weight: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type CastVoteArgs = z.infer<typeof CastVoteArgsSchema>;
+/**
+ * Arguments for querying mandates
+ */
+export declare const QueryMandatesArgsSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        candidate: "candidate";
+        established: "established";
+        mandate: "mandate";
+        rejected: "rejected";
+    }>>;
+    content_type: z.ZodOptional<z.ZodEnum<{
+        idea: "idea";
+        tip: "tip";
+        lore: "lore";
+        snippet: "snippet";
+        feature_request: "feature_request";
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    author_agent: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    min_score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type QueryMandatesArgs = z.infer<typeof QueryMandatesArgsSchema>;
+/**
+ * Result of score calculation
+ */
+export declare const ScoreCalculationResultSchema: z.ZodObject<{
+    mandate_id: z.ZodString;
+    previous_status: z.ZodEnum<{
+        candidate: "candidate";
+        established: "established";
+        mandate: "mandate";
+        rejected: "rejected";
+    }>;
+    new_status: z.ZodEnum<{
+        candidate: "candidate";
+        established: "established";
+        mandate: "mandate";
+        rejected: "rejected";
+    }>;
+    score: z.ZodObject<{
+        mandate_id: z.ZodString;
+        net_votes: z.ZodNumber;
+        vote_ratio: z.ZodNumber;
+        decayed_score: z.ZodNumber;
+        last_calculated: z.ZodString;
+        raw_upvotes: z.ZodNumber;
+        raw_downvotes: z.ZodNumber;
+        decayed_upvotes: z.ZodNumber;
+        decayed_downvotes: z.ZodNumber;
+    }, z.core.$strip>;
+    status_changed: z.ZodBoolean;
+}, z.core.$strip>;
+export type ScoreCalculationResult = z.infer<typeof ScoreCalculationResultSchema>;
+export declare const mandateSchemas: {
+    MandateContentTypeSchema: z.ZodEnum<{
+        idea: "idea";
+        tip: "tip";
+        lore: "lore";
+        snippet: "snippet";
+        feature_request: "feature_request";
+    }>;
+    MandateStatusSchema: z.ZodEnum<{
+        candidate: "candidate";
+        established: "established";
+        mandate: "mandate";
+        rejected: "rejected";
+    }>;
+    VoteTypeSchema: z.ZodEnum<{
+        upvote: "upvote";
+        downvote: "downvote";
+    }>;
+    MandateEntrySchema: z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        content_type: z.ZodEnum<{
+            idea: "idea";
+            tip: "tip";
+            lore: "lore";
+            snippet: "snippet";
+            feature_request: "feature_request";
+        }>;
+        author_agent: z.ZodString;
+        created_at: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            candidate: "candidate";
+            established: "established";
+            mandate: "mandate";
+            rejected: "rejected";
+        }>>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    VoteSchema: z.ZodObject<{
+        id: z.ZodString;
+        mandate_id: z.ZodString;
+        agent_name: z.ZodString;
+        vote_type: z.ZodEnum<{
+            upvote: "upvote";
+            downvote: "downvote";
+        }>;
+        timestamp: z.ZodString;
+        weight: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    MandateScoreSchema: z.ZodObject<{
+        mandate_id: z.ZodString;
+        net_votes: z.ZodNumber;
+        vote_ratio: z.ZodNumber;
+        decayed_score: z.ZodNumber;
+        last_calculated: z.ZodString;
+        raw_upvotes: z.ZodNumber;
+        raw_downvotes: z.ZodNumber;
+        decayed_upvotes: z.ZodNumber;
+        decayed_downvotes: z.ZodNumber;
+    }, z.core.$strip>;
+    CreateMandateArgsSchema: z.ZodObject<{
+        content: z.ZodString;
+        content_type: z.ZodEnum<{
+            idea: "idea";
+            tip: "tip";
+            lore: "lore";
+            snippet: "snippet";
+            feature_request: "feature_request";
+        }>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    CastVoteArgsSchema: z.ZodObject<{
+        mandate_id: z.ZodString;
+        vote_type: z.ZodEnum<{
+            upvote: "upvote";
+            downvote: "downvote";
+        }>;
+        weight: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    QueryMandatesArgsSchema: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            candidate: "candidate";
+            established: "established";
+            mandate: "mandate";
+            rejected: "rejected";
+        }>>;
+        content_type: z.ZodOptional<z.ZodEnum<{
+            idea: "idea";
+            tip: "tip";
+            lore: "lore";
+            snippet: "snippet";
+            feature_request: "feature_request";
+        }>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        author_agent: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        min_score: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    ScoreCalculationResultSchema: z.ZodObject<{
+        mandate_id: z.ZodString;
+        previous_status: z.ZodEnum<{
+            candidate: "candidate";
+            established: "established";
+            mandate: "mandate";
+            rejected: "rejected";
+        }>;
+        new_status: z.ZodEnum<{
+            candidate: "candidate";
+            established: "established";
+            mandate: "mandate";
+            rejected: "rejected";
+        }>;
+        score: z.ZodObject<{
+            mandate_id: z.ZodString;
+            net_votes: z.ZodNumber;
+            vote_ratio: z.ZodNumber;
+            decayed_score: z.ZodNumber;
+            last_calculated: z.ZodString;
+            raw_upvotes: z.ZodNumber;
+            raw_downvotes: z.ZodNumber;
+            decayed_upvotes: z.ZodNumber;
+            decayed_downvotes: z.ZodNumber;
+        }, z.core.$strip>;
+        status_changed: z.ZodBoolean;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=mandate.d.ts.map

package/dist/schemas/mandate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mandate.d.ts","sourceRoot":"","sources":["../../src/schemas/mandate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;EAMnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;;;;;EAK9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,cAAc;;;EAAiC,CAAC;AAC7D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAMtD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;iBAiB7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAM9D;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;iBAarB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAM9C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;iBAiB7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAM9D;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,wBAAwB,EAAE,MAAM,CAAC;IACjC,8CAA8C;IAC9C,yBAAyB,EAAE,MAAM,CAAC;IAClC,iDAAiD;IACjD,4BAA4B,EAAE,MAAM,CAAC;IACrC,uDAAuD;IACvD,yBAAyB,EAAE,MAAM,CAAC;CACnC;AAED,eAAO,MAAM,4BAA4B,EAAE,kBAM1C,CAAC;AAMF;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAKlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;iBAI7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;iBAOlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAMF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAW1B,CAAC"}

package/dist/schemas/swarm-context.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Swarm Context Schemas
+ *
+ * These schemas define the structure for storing and recovering swarm execution context.
+ * Used for checkpoint/recovery, continuation after crashes, and swarm state management.
+ */
+import { z } from "zod";
+/**
+ * Decomposition strategy used for the swarm
+ */
+export declare const SwarmStrategySchema: z.ZodEnum<{
+    "file-based": "file-based";
+    "feature-based": "feature-based";
+    "risk-based": "risk-based";
+}>;
+export type SwarmStrategy = z.infer<typeof SwarmStrategySchema>;
+/**
+ * Shared directives and context for all agents in a swarm
+ */
+export declare const SwarmDirectivesSchema: z.ZodObject<{
+    shared_context: z.ZodString;
+    skills_to_load: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    coordinator_notes: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type SwarmDirectives = z.infer<typeof SwarmDirectivesSchema>;
+/**
+ * Recovery state for checkpoint/resume
+ */
+export declare const SwarmRecoverySchema: z.ZodObject<{
+    last_checkpoint: z.ZodString;
+    files_modified: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    progress_percent: z.ZodDefault<z.ZodNumber>;
+    last_message: z.ZodDefault<z.ZodString>;
+    error_context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SwarmRecovery = z.infer<typeof SwarmRecoverySchema>;
+/**
+ * Complete context for a single bead in a swarm
+ *
+ * Stored in swarm_contexts table for recovery, continuation, and state management.
+ */
+export declare const SwarmBeadContextSchema: z.ZodObject<{
+    id: z.ZodString;
+    epic_id: z.ZodString;
+    bead_id: z.ZodString;
+    strategy: z.ZodEnum<{
+        "file-based": "file-based";
+        "feature-based": "feature-based";
+        "risk-based": "risk-based";
+    }>;
+    files: z.ZodArray<z.ZodString>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    directives: z.ZodObject<{
+        shared_context: z.ZodString;
+        skills_to_load: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        coordinator_notes: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    recovery: z.ZodObject<{
+        last_checkpoint: z.ZodString;
+        files_modified: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        progress_percent: z.ZodDefault<z.ZodNumber>;
+        last_message: z.ZodDefault<z.ZodString>;
+        error_context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    created_at: z.ZodNumber;
+    updated_at: z.ZodNumber;
+}, z.core.$strip>;
+export type SwarmBeadContext = z.infer<typeof SwarmBeadContextSchema>;
+/**
+ * Args for creating a swarm context
+ */
+export declare const CreateSwarmContextArgsSchema: z.ZodObject<{
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    files: z.ZodArray<z.ZodString>;
+    epic_id: z.ZodString;
+    bead_id: z.ZodString;
+    strategy: z.ZodEnum<{
+        "file-based": "file-based";
+        "feature-based": "feature-based";
+        "risk-based": "risk-based";
+    }>;
+    directives: z.ZodObject<{
+        shared_context: z.ZodString;
+        skills_to_load: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        coordinator_notes: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    recovery: z.ZodObject<{
+        last_checkpoint: z.ZodString;
+        files_modified: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        progress_percent: z.ZodDefault<z.ZodNumber>;
+        last_message: z.ZodDefault<z.ZodString>;
+        error_context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CreateSwarmContextArgs = z.infer<typeof CreateSwarmContextArgsSchema>;
+/**
+ * Args for updating a swarm context
+ */
+export declare const UpdateSwarmContextArgsSchema: z.ZodObject<{
+    id: z.ZodString;
+    recovery: z.ZodOptional<z.ZodObject<{
+        last_checkpoint: z.ZodOptional<z.ZodString>;
+        files_modified: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        progress_percent: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        last_message: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        error_context: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    directives: z.ZodOptional<z.ZodObject<{
+        shared_context: z.ZodOptional<z.ZodString>;
+        skills_to_load: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        coordinator_notes: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UpdateSwarmContextArgs = z.infer<typeof UpdateSwarmContextArgsSchema>;
+/**
+ * Args for querying swarm contexts
+ */
+export declare const QuerySwarmContextsArgsSchema: z.ZodObject<{
+    epic_id: z.ZodOptional<z.ZodString>;
+    bead_id: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        "file-based": "file-based";
+        "feature-based": "feature-based";
+        "risk-based": "risk-based";
+    }>>;
+    has_errors: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type QuerySwarmContextsArgs = z.infer<typeof QuerySwarmContextsArgsSchema>;
+//# sourceMappingURL=swarm-context.d.ts.map

package/dist/schemas/swarm-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swarm-context.d.ts","sourceRoot":"","sources":["../../src/schemas/swarm-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;iBAOhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;iBAW9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;iBAIvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;iBAMvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;iBAKvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC"}