opencode-swarm-plugin 0.56.1 → 0.57.1

package/claude-plugin/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/claude-plugin/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/claude-plugin/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<{
+    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>;
+}, 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/claude-plugin/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"}

package/claude-plugin/dist/schemas/task.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Task decomposition schemas
+ *
+ * These schemas define the structure for breaking down tasks
+ * into parallelizable subtasks for swarm execution.
+ */
+import { z } from "zod";
+/**
+ * Effort estimation for subtasks.
+ *
+ * Time ranges:
+ * - `trivial`: < 5 minutes (simple rename, typo fix)
+ * - `small`: 5-30 minutes (single function, simple feature)
+ * - `medium`: 30 min - 2 hours (multi-file change, moderate complexity)
+ * - `large`: 2+ hours (significant feature, refactoring)
+ */
+export declare const EffortLevelSchema: z.ZodEnum<{
+    small: "small";
+    medium: "medium";
+    trivial: "trivial";
+    large: "large";
+}>;
+export type EffortLevel = z.infer<typeof EffortLevelSchema>;
+/**
+ * Dependency type between subtasks
+ */
+export declare const DependencyTypeSchema: z.ZodEnum<{
+    blocks: "blocks";
+    related: "related";
+    requires: "requires";
+}>;
+export type DependencyType = z.infer<typeof DependencyTypeSchema>;
+/**
+ * Subtask in a decomposition
+ */
+export declare const DecomposedSubtaskSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    files: z.ZodArray<z.ZodString>;
+    estimated_effort: z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        trivial: "trivial";
+        large: "large";
+    }>;
+    risks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DecomposedSubtask = z.infer<typeof DecomposedSubtaskSchema>;
+/**
+ * Dependency between subtasks
+ */
+export declare const SubtaskDependencySchema: z.ZodObject<{
+    from: z.ZodNumber;
+    to: z.ZodNumber;
+    type: z.ZodEnum<{
+        blocks: "blocks";
+        related: "related";
+        requires: "requires";
+    }>;
+}, z.core.$strip>;
+export type SubtaskDependency = z.infer<typeof SubtaskDependencySchema>;
+/**
+ * Full task decomposition result
+ *
+ * Returned by the decomposition agent, validated before spawning.
+ */
+export declare const TaskDecompositionSchema: z.ZodObject<{
+    task: z.ZodString;
+    reasoning: z.ZodOptional<z.ZodString>;
+    subtasks: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        estimated_effort: z.ZodEnum<{
+            small: "small";
+            medium: "medium";
+            trivial: "trivial";
+            large: "large";
+        }>;
+        risks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+        type: z.ZodEnum<{
+            blocks: "blocks";
+            related: "related";
+            requires: "requires";
+        }>;
+    }, z.core.$strip>>>>;
+    shared_context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TaskDecomposition = z.infer<typeof TaskDecompositionSchema>;
+/**
+ * Arguments for task decomposition
+ */
+export declare const DecomposeArgsSchema: z.ZodObject<{
+    task: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DecomposeArgs = z.infer<typeof DecomposeArgsSchema>;
+/**
+ * Spawn result for a single agent
+ */
+export declare const SpawnedAgentSchema: z.ZodObject<{
+    bead_id: z.ZodString;
+    agent_name: z.ZodString;
+    task_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+    }>;
+    files: z.ZodArray<z.ZodString>;
+    reservation_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type SpawnedAgent = z.infer<typeof SpawnedAgentSchema>;
+/**
+ * Result of spawning a swarm
+ */
+export declare const SwarmSpawnResultSchema: z.ZodObject<{
+    epic_id: z.ZodString;
+    coordinator_name: z.ZodString;
+    thread_id: z.ZodString;
+    agents: z.ZodArray<z.ZodObject<{
+        bead_id: z.ZodString;
+        agent_name: z.ZodString;
+        task_id: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            running: "running";
+            completed: "completed";
+        }>;
+        files: z.ZodArray<z.ZodString>;
+        reservation_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    started_at: z.ZodString;
+}, z.core.$strip>;
+export type SwarmSpawnResult = z.infer<typeof SwarmSpawnResultSchema>;
+/**
+ * Progress update from an agent
+ */
+export declare const AgentProgressSchema: z.ZodObject<{
+    bead_id: z.ZodString;
+    agent_name: z.ZodString;
+    status: z.ZodEnum<{
+        in_progress: "in_progress";
+        blocked: "blocked";
+        failed: "failed";
+        completed: "completed";
+    }>;
+    progress_percent: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type AgentProgress = z.infer<typeof AgentProgressSchema>;
+/**
+ * Swarm status summary
+ */
+export declare const SwarmStatusSchema: z.ZodObject<{
+    epic_id: z.ZodString;
+    total_agents: z.ZodNumber;
+    running: z.ZodNumber;
+    completed: z.ZodNumber;
+    failed: z.ZodNumber;
+    blocked: z.ZodNumber;
+    agents: z.ZodArray<z.ZodObject<{
+        bead_id: z.ZodString;
+        agent_name: z.ZodString;
+        task_id: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            running: "running";
+            completed: "completed";
+        }>;
+        files: z.ZodArray<z.ZodString>;
+        reservation_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    last_update: z.ZodString;
+}, z.core.$strip>;
+export type SwarmStatus = z.infer<typeof SwarmStatusSchema>;
+//# sourceMappingURL=task.d.ts.map

package/claude-plugin/dist/schemas/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/schemas/task.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;EAI/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAYlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;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,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAe7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;iBAe7B,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}