opencode-swarm-plugin 0.56.1 → 0.57.0

package/claude-plugin/dist/observability-tools.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Observability Tools - Agent-facing Analytics
+ *
+ * Exposes observability tools to agents via plugin tools.
+ * Agents get programmatic access to analytics, not just CLI.
+ *
+ * Tools:
+ * - swarm_analytics: Query pre-built analytics
+ * - swarm_query: Raw SQL for power users
+ * - swarm_diagnose: Auto-diagnosis for epic/task
+ * - swarm_insights: Generate learning insights
+ */
+export interface SwarmAnalyticsArgs {
+    query: "failed-decompositions" | "strategy-success-rates" | "lock-contention" | "agent-activity" | "message-latency" | "scope-violations" | "task-duration" | "checkpoint-frequency" | "recovery-success" | "human-feedback";
+    since?: string;
+    format?: "json" | "summary";
+}
+export interface SwarmQueryArgs {
+    sql: string;
+    format?: "json" | "table";
+}
+export interface SwarmDiagnoseArgs {
+    epic_id?: string;
+    bead_id?: string;
+    include?: Array<"blockers" | "conflicts" | "slow_tasks" | "errors" | "timeline">;
+}
+export interface SwarmInsightsArgs {
+    scope: "epic" | "project" | "recent";
+    epic_id?: string;
+    metrics: Array<"success_rate" | "avg_duration" | "conflict_rate" | "retry_rate">;
+}
+export interface SwarmStatsData {
+    overall: {
+        totalSwarms: number;
+        successRate: number;
+        avgDurationMin: number;
+    };
+    byStrategy: Array<{
+        strategy: string;
+        total: number;
+        successRate: number;
+        successes: number;
+    }>;
+    coordinator: {
+        violationRate: number;
+        spawnEfficiency: number;
+        reviewThoroughness: number;
+    };
+    recentDays: number;
+}
+/**
+ * Format swarm stats as beautiful CLI output with box drawing
+ */
+export declare function formatSwarmStats(stats: SwarmStatsData): string;
+/**
+ * Parse time period string like "7d", "24h", "30m" to timestamp
+ */
+export declare function parseTimePeriod(period: string): number;
+/**
+ * Aggregate swarm outcomes by strategy
+ */
+export declare function aggregateByStrategy(outcomes: Array<{
+    strategy: string | null;
+    success: boolean;
+}>): Array<{
+    strategy: string;
+    total: number;
+    successRate: number;
+    successes: number;
+}>;
+export interface SwarmHistoryRecord {
+    epic_id: string;
+    epic_title: string;
+    strategy: string;
+    timestamp: string;
+    overall_success: boolean;
+    task_count: number;
+    completed_count: number;
+}
+/**
+ * Query swarm history from swarm events
+ *
+ * Constructs epic-level view from decomposition_generated and subtask_outcome events:
+ * - decomposition_generated: epic_id, task (title), strategy, subtask_count
+ * - subtask_outcome: count successful completed tasks per epic
+ */
+export declare function querySwarmHistory(projectPath: string, options?: {
+    limit?: number;
+    status?: "success" | "failed" | "in_progress";
+    strategy?: "file-based" | "feature-based" | "risk-based";
+}): Promise<SwarmHistoryRecord[]>;
+/**
+ * Format relative time (e.g., "2h ago", "1d ago")
+ */
+export declare function formatRelativeTime(timestamp: string): string;
+/**
+ * Format swarm history as beautiful CLI table
+ */
+export declare function formatSwarmHistory(records: SwarmHistoryRecord[]): string;
+export declare const observabilityTools: {
+    swarm_analytics: {
+        description: string;
+        args: {
+            query: import("zod").ZodEnum<{
+                "failed-decompositions": "failed-decompositions";
+                "strategy-success-rates": "strategy-success-rates";
+                "lock-contention": "lock-contention";
+                "agent-activity": "agent-activity";
+                "message-latency": "message-latency";
+                "scope-violations": "scope-violations";
+                "task-duration": "task-duration";
+                "checkpoint-frequency": "checkpoint-frequency";
+                "recovery-success": "recovery-success";
+                "human-feedback": "human-feedback";
+            }>;
+            since: import("zod").ZodOptional<import("zod").ZodString>;
+            format: import("zod").ZodOptional<import("zod").ZodEnum<{
+                summary: "summary";
+                json: "json";
+            }>>;
+        };
+        execute(args: {
+            query: "failed-decompositions" | "strategy-success-rates" | "lock-contention" | "agent-activity" | "message-latency" | "scope-violations" | "task-duration" | "checkpoint-frequency" | "recovery-success" | "human-feedback";
+            since?: string | undefined;
+            format?: "summary" | "json" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_query: {
+        description: string;
+        args: {
+            sql: import("zod").ZodString;
+            format: import("zod").ZodOptional<import("zod").ZodEnum<{
+                table: "table";
+                json: "json";
+            }>>;
+        };
+        execute(args: {
+            sql: string;
+            format?: "table" | "json" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_diagnose: {
+        description: string;
+        args: {
+            epic_id: import("zod").ZodOptional<import("zod").ZodString>;
+            bead_id: import("zod").ZodOptional<import("zod").ZodString>;
+            include: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                errors: "errors";
+                blockers: "blockers";
+                conflicts: "conflicts";
+                slow_tasks: "slow_tasks";
+                timeline: "timeline";
+            }>>>;
+        };
+        execute(args: {
+            epic_id?: string | undefined;
+            bead_id?: string | undefined;
+            include?: ("errors" | "blockers" | "conflicts" | "slow_tasks" | "timeline")[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_insights: {
+        description: string;
+        args: {
+            scope: import("zod").ZodEnum<{
+                project: "project";
+                epic: "epic";
+                recent: "recent";
+            }>;
+            epic_id: import("zod").ZodOptional<import("zod").ZodString>;
+            metrics: import("zod").ZodArray<import("zod").ZodEnum<{
+                success_rate: "success_rate";
+                avg_duration: "avg_duration";
+                conflict_rate: "conflict_rate";
+                retry_rate: "retry_rate";
+            }>>;
+        };
+        execute(args: {
+            scope: "project" | "epic" | "recent";
+            metrics: ("success_rate" | "avg_duration" | "conflict_rate" | "retry_rate")[];
+            epic_id?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=observability-tools.d.ts.map

package/claude-plugin/dist/observability-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability-tools.d.ts","sourceRoot":"","sources":["../src/observability-tools.ts"],"names":[],"mappings":"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"}

package/claude-plugin/dist/output-guardrails.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Output Guardrails for MCP Tool Response Truncation
+ *
+ * Prevents MCP tools from blowing out context with massive responses.
+ * Provides smart truncation that preserves JSON, code blocks, and markdown structure.
+ *
+ * @module output-guardrails
+ *
+ * @example
+ * ```typescript
+ * import { guardrailOutput, DEFAULT_GUARDRAIL_CONFIG } from "./output-guardrails"
+ *
+ * const result = guardrailOutput("context7_get-library-docs", hugeOutput)
+ * if (result.truncated) {
+ *   console.log(`Truncated ${result.originalLength - result.truncatedLength} chars`)
+ * }
+ * ```
+ */
+/**
+ * Guardrail configuration for tool output limits
+ *
+ * Controls per-tool character limits and skip rules.
+ */
+export interface GuardrailConfig {
+    /**
+     * Default max characters for tool output
+     * Default: 32000 chars (~8000 tokens at 4 chars/token)
+     */
+    defaultMaxChars: number;
+    /**
+     * Per-tool character limit overrides
+     *
+     * Higher limits for code/doc tools that commonly return large outputs.
+     */
+    toolLimits: Record<string, number>;
+    /**
+     * Tools that should never be truncated
+     *
+     * Internal coordination tools (beads_*, swarmmail_*, structured_*)
+     * should always return complete output.
+     */
+    skipTools: string[];
+}
+/**
+ * Result of guardrail output processing
+ */
+export interface GuardrailResult {
+    /** Processed output (truncated if needed) */
+    output: string;
+    /** Whether truncation occurred */
+    truncated: boolean;
+    /** Original output length in characters */
+    originalLength: number;
+    /** Final output length in characters */
+    truncatedLength: number;
+}
+/**
+ * Metrics for guardrail analytics
+ *
+ * Used to track truncation patterns and adjust limits.
+ */
+export interface GuardrailMetrics {
+    /** Tool that produced the output */
+    toolName: string;
+    /** Original output length */
+    originalLength: number;
+    /** Truncated output length */
+    truncatedLength: number;
+    /** Timestamp of truncation */
+    timestamp: number;
+}
+/**
+ * Default guardrail configuration
+ *
+ * - defaultMaxChars: 32000 (~8000 tokens)
+ * - Higher limits for code/doc tools (64000)
+ * - Skip internal coordination tools
+ */
+export declare const DEFAULT_GUARDRAIL_CONFIG: GuardrailConfig;
+/**
+ * Smart truncation preserving structure boundaries
+ *
+ * Truncates text while preserving:
+ * - JSON structure (finds matching braces, doesn't cut mid-object)
+ * - Code blocks (preserves ``` boundaries)
+ * - Markdown headers (cuts at ## boundaries when possible)
+ *
+ * @param text - Text to truncate
+ * @param maxChars - Maximum character count
+ * @returns Truncated text with "[TRUNCATED - X chars removed]" suffix
+ */
+export declare function truncateWithBoundaries(text: string, maxChars: number): string;
+/**
+ * Apply guardrails to tool output
+ *
+ * Main entry point for guardrail processing:
+ * 1. Check if tool is in skipTools → return unchanged
+ * 2. Check if output.length > getToolLimit(toolName) → truncate
+ * 3. Return { output, truncated, originalLength, truncatedLength }
+ *
+ * @param toolName - Name of the tool that produced the output
+ * @param output - Tool output to process
+ * @param config - Optional guardrail configuration (defaults to DEFAULT_GUARDRAIL_CONFIG)
+ * @returns Guardrail result with truncated output and metadata
+ *
+ * @example
+ * ```typescript
+ * const result = guardrailOutput("context7_get-library-docs", hugeOutput)
+ * console.log(result.output)  // Truncated or original
+ * console.log(result.truncated)  // true if truncated
+ * console.log(`${result.originalLength} → ${result.truncatedLength} chars`)
+ * ```
+ */
+export declare function guardrailOutput(toolName: string, output: string, config?: GuardrailConfig): GuardrailResult;
+/**
+ * Create a guardrail metrics entry
+ *
+ * Used for analytics and learning about truncation patterns.
+ *
+ * @param result - Guardrail result from guardrailOutput
+ * @param toolName - Name of the tool
+ * @returns Metrics entry
+ */
+export declare function createMetrics(result: GuardrailResult, toolName: string): GuardrailMetrics;
+//# sourceMappingURL=output-guardrails.d.ts.map

package/claude-plugin/dist/output-guardrails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-guardrails.d.ts","sourceRoot":"","sources":["../src/output-guardrails.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEnC;;;;;OAKG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IAEf,kCAAkC;IAClC,SAAS,EAAE,OAAO,CAAC;IAEnB,2CAA2C;IAC3C,cAAc,EAAE,MAAM,CAAC;IAEvB,wCAAwC;IACxC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IAEjB,6BAA6B;IAC7B,cAAc,EAAE,MAAM,CAAC;IAEvB,8BAA8B;IAC9B,eAAe,EAAE,MAAM,CAAC;IAExB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,eA+EtC,CAAC;AA+BF;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAwE7E;AAgBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,eAA0C,GACjD,eAAe,CAoCjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,MAAM,GACf,gBAAgB,CAOlB"}

package/claude-plugin/dist/pattern-maturity.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Pattern Maturity Module
+ *
+ * Tracks decomposition pattern maturity states through lifecycle:
+ * candidate → established → proven (or deprecated)
+ *
+ * Patterns start as candidates until they accumulate enough feedback.
+ * Strong positive feedback promotes to proven, strong negative deprecates.
+ *
+ * @see https://github.com/Dicklesworthstone/cass_memory_system/blob/main/src/scoring.ts#L73-L98
+ */
+import { z } from "zod";
+/**
+ * Maturity state for a decomposition pattern
+ *
+ * - candidate: Not enough feedback to judge (< minFeedback events)
+ * - established: Enough feedback, neither proven nor deprecated
+ * - proven: Strong positive signal (high helpful, low harmful ratio)
+ * - deprecated: Strong negative signal (high harmful ratio)
+ */
+export declare const MaturityStateSchema: z.ZodEnum<{
+    deprecated: "deprecated";
+    candidate: "candidate";
+    established: "established";
+    proven: "proven";
+}>;
+export type MaturityState = z.infer<typeof MaturityStateSchema>;
+/**
+ * Pattern maturity tracking
+ *
+ * Tracks feedback counts and state transitions for a decomposition pattern.
+ */
+export declare const PatternMaturitySchema: z.ZodObject<{
+    pattern_id: z.ZodString;
+    state: z.ZodEnum<{
+        deprecated: "deprecated";
+        candidate: "candidate";
+        established: "established";
+        proven: "proven";
+    }>;
+    helpful_count: z.ZodNumber;
+    harmful_count: z.ZodNumber;
+    last_validated: z.ZodString;
+    promoted_at: z.ZodOptional<z.ZodString>;
+    deprecated_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PatternMaturity = z.infer<typeof PatternMaturitySchema>;
+/**
+ * Feedback event for maturity tracking
+ */
+export declare const MaturityFeedbackSchema: z.ZodObject<{
+    pattern_id: z.ZodString;
+    type: z.ZodEnum<{
+        helpful: "helpful";
+        harmful: "harmful";
+    }>;
+    timestamp: z.ZodString;
+    weight: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type MaturityFeedback = z.infer<typeof MaturityFeedbackSchema>;
+/**
+ * Configuration for maturity calculations
+ */
+export interface MaturityConfig {
+    /** Minimum feedback events before leaving candidate state */
+    minFeedback: number;
+    /** Minimum decayed helpful score to reach proven state */
+    minHelpful: number;
+    /** Maximum harmful ratio to reach/maintain proven state */
+    maxHarmful: number;
+    /** Harmful ratio threshold for deprecation */
+    deprecationThreshold: number;
+    /** Half-life for decay in days */
+    halfLifeDays: number;
+}
+export declare const DEFAULT_MATURITY_CONFIG: MaturityConfig;
+/**
+ * Calculate decayed feedback counts
+ *
+ * Applies half-life decay to each feedback event based on age.
+ *
+ * @param feedbackEvents - Raw feedback events
+ * @param config - Maturity configuration
+ * @param now - Current timestamp for decay calculation
+ * @returns Decayed helpful and harmful totals
+ */
+export declare function calculateDecayedCounts(feedbackEvents: MaturityFeedback[], config?: MaturityConfig, now?: Date): {
+    decayedHelpful: number;
+    decayedHarmful: number;
+};
+/**
+ * Calculate maturity state from feedback events
+ *
+ * State determination logic:
+ * 1. "deprecated" if harmful ratio > 0.3 AND total >= minFeedback
+ * 2. "candidate" if total < minFeedback (not enough data)
+ * 3. "proven" if decayedHelpful >= minHelpful AND harmfulRatio < maxHarmful
+ * 4. "established" otherwise (enough data but not yet proven)
+ *
+ * @param feedbackEvents - Feedback events for this pattern
+ * @param config - Maturity configuration
+ * @param now - Current timestamp for decay calculation
+ * @returns Calculated maturity state
+ */
+export declare function calculateMaturityState(feedbackEvents: MaturityFeedback[], config?: MaturityConfig, now?: Date): MaturityState;
+/**
+ * Create initial pattern maturity record
+ *
+ * @param patternId - Unique pattern identifier
+ * @returns New PatternMaturity in candidate state
+ */
+export declare function createPatternMaturity(patternId: string): PatternMaturity;
+/**
+ * Update pattern maturity with new feedback.
+ *
+ * Side Effects:
+ * - Sets `promoted_at` timestamp on first entry into 'proven' status
+ * - Sets `deprecated_at` timestamp on first entry into 'deprecated' status
+ * - Updates `helpful_count` and `harmful_count` based on feedback events
+ * - Recalculates `state` based on decayed feedback counts
+ *
+ * State Transitions:
+ * - candidate → established: After minFeedback observations (default 3)
+ * - established → proven: When decayedHelpful >= minHelpful (5) AND harmfulRatio < maxHarmful (15%)
+ * - any → deprecated: When harmfulRatio > deprecationThreshold (30%) AND total >= minFeedback
+ *
+ * @param maturity - Current maturity record
+ * @param feedbackEvents - All feedback events for this pattern
+ * @param config - Maturity configuration
+ * @returns Updated maturity record with new state
+ */
+export declare function updatePatternMaturity(maturity: PatternMaturity, feedbackEvents: MaturityFeedback[], config?: MaturityConfig): PatternMaturity;
+/**
+ * Promote a pattern to proven state
+ *
+ * Manually promotes a pattern regardless of feedback counts.
+ * Use when external validation confirms pattern effectiveness.
+ *
+ * @param maturity - Current maturity record
+ * @returns Updated maturity record with proven state
+ */
+export declare function promotePattern(maturity: PatternMaturity): PatternMaturity;
+/**
+ * Deprecate a pattern
+ *
+ * Manually deprecates a pattern regardless of feedback counts.
+ * Use when external validation shows pattern is harmful.
+ *
+ * @param maturity - Current maturity record
+ * @param reason - Optional reason for deprecation
+ * @returns Updated maturity record with deprecated state
+ */
+export declare function deprecatePattern(maturity: PatternMaturity, _reason?: string): PatternMaturity;
+/**
+ * Get weight multiplier based on pattern maturity status.
+ *
+ * Multipliers chosen to:
+ * - Heavily penalize deprecated patterns (0x) - never recommend
+ * - Slightly boost proven patterns (1.5x) - reward validated success
+ * - Penalize unvalidated candidates (0.5x) - reduce impact until proven
+ * - Neutral for established (1.0x) - baseline weight
+ *
+ * @param state - Pattern maturity status
+ * @returns Multiplier to apply to pattern weight
+ */
+export declare function getMaturityMultiplier(state: MaturityState): number;
+/**
+ * Format maturity state for inclusion in prompts
+ *
+ * Shows pattern reliability to help agents make informed decisions.
+ *
+ * @param maturity - Pattern maturity record
+ * @returns Formatted string describing pattern reliability
+ */
+export declare function formatMaturityForPrompt(maturity: PatternMaturity): string;
+/**
+ * Format multiple patterns with maturity for prompt inclusion
+ *
+ * Groups patterns by maturity state for clear presentation.
+ *
+ * @param patterns - Map of pattern content to maturity record
+ * @returns Formatted string for prompt inclusion
+ */
+export declare function formatPatternsWithMaturityForPrompt(patterns: Map<string, PatternMaturity>): string;
+/**
+ * Storage interface for pattern maturity records
+ */
+export interface MaturityStorage {
+    /** Store or update a maturity record */
+    store(maturity: PatternMaturity): Promise<void>;
+    /** Get maturity record by pattern ID */
+    get(patternId: string): Promise<PatternMaturity | null>;
+    /** Get all maturity records */
+    getAll(): Promise<PatternMaturity[]>;
+    /** Get patterns by state */
+    getByState(state: MaturityState): Promise<PatternMaturity[]>;
+    /** Store a feedback event */
+    storeFeedback(feedback: MaturityFeedback): Promise<void>;
+    /** Get all feedback for a pattern */
+    getFeedback(patternId: string): Promise<MaturityFeedback[]>;
+}
+/**
+ * In-memory maturity storage (for testing and short-lived sessions)
+ */
+export declare class InMemoryMaturityStorage implements MaturityStorage {
+    private maturities;
+    private feedback;
+    store(maturity: PatternMaturity): Promise<void>;
+    get(patternId: string): Promise<PatternMaturity | null>;
+    getAll(): Promise<PatternMaturity[]>;
+    getByState(state: MaturityState): Promise<PatternMaturity[]>;
+    storeFeedback(feedback: MaturityFeedback): Promise<void>;
+    getFeedback(patternId: string): Promise<MaturityFeedback[]>;
+}
+export declare const maturitySchemas: {
+    MaturityStateSchema: z.ZodEnum<{
+        deprecated: "deprecated";
+        candidate: "candidate";
+        established: "established";
+        proven: "proven";
+    }>;
+    PatternMaturitySchema: z.ZodObject<{
+        pattern_id: z.ZodString;
+        state: z.ZodEnum<{
+            deprecated: "deprecated";
+            candidate: "candidate";
+            established: "established";
+            proven: "proven";
+        }>;
+        helpful_count: z.ZodNumber;
+        harmful_count: z.ZodNumber;
+        last_validated: z.ZodString;
+        promoted_at: z.ZodOptional<z.ZodString>;
+        deprecated_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    MaturityFeedbackSchema: z.ZodObject<{
+        pattern_id: z.ZodString;
+        type: z.ZodEnum<{
+            helpful: "helpful";
+            harmful: "harmful";
+        }>;
+        timestamp: z.ZodString;
+        weight: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=pattern-maturity.d.ts.map

package/claude-plugin/dist/pattern-maturity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-maturity.d.ts","sourceRoot":"","sources":["../src/pattern-maturity.ts"],"names":[],"mappings":"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"}