opencode-swarm-plugin 0.22.0 → 0.23.1

package/dist/mandate-promotion.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Mandate Promotion Engine
+ *
+ * Handles state transitions for mandate entries based on vote scores:
+ * - candidate → established: net_votes >= 2
+ * - established → mandate: net_votes >= 5 AND vote_ratio >= 0.7
+ * - any → rejected: net_votes <= -3
+ *
+ * Integrates with pattern-maturity.ts decay calculations and state machine patterns.
+ */
+import type { MandateDecayConfig, MandateEntry, MandateScore, MandateStatus } from "./schemas/mandate";
+/**
+ * Result of a promotion evaluation
+ */
+export interface PromotionResult {
+    /** The mandate entry ID */
+    mandate_id: string;
+    /** Status before evaluation */
+    previous_status: MandateStatus;
+    /** Status after evaluation */
+    new_status: MandateStatus;
+    /** Calculated score */
+    score: MandateScore;
+    /** Whether status changed */
+    promoted: boolean;
+    /** Human-readable reason for the transition (or lack thereof) */
+    reason: string;
+}
+/**
+ * Determine new status based on score and current status
+ *
+ * State machine:
+ * - candidate → established: net_votes >= establishedNetVotesThreshold (2)
+ * - established → mandate: net_votes >= mandateNetVotesThreshold (5) AND vote_ratio >= mandateVoteRatioThreshold (0.7)
+ * - any → rejected: net_votes <= rejectedNetVotesThreshold (-3)
+ * - mandate stays mandate (no demotion)
+ * - rejected stays rejected (permanent)
+ *
+ * @param score - Calculated mandate score with decayed votes
+ * @param currentStatus - Current status of the mandate entry
+ * @param config - Threshold configuration
+ * @returns New status after applying transition rules
+ */
+export declare function shouldPromote(score: MandateScore, currentStatus: MandateStatus, config?: MandateDecayConfig): MandateStatus;
+/**
+ * Evaluate promotion for a mandate entry
+ *
+ * Main entry point for promotion logic. Calculates new status and provides
+ * detailed reasoning for the decision.
+ *
+ * @param entry - The mandate entry to evaluate
+ * @param score - Calculated score with decayed votes
+ * @param config - Threshold configuration (optional)
+ * @returns Promotion result with status change and reasoning
+ */
+export declare function evaluatePromotion(entry: MandateEntry, score: MandateScore, config?: MandateDecayConfig): PromotionResult;
+/**
+ * Format promotion result for logging or display
+ *
+ * @param result - Promotion result
+ * @returns Formatted string
+ */
+export declare function formatPromotionResult(result: PromotionResult): string;
+/**
+ * Batch evaluate promotions for multiple entries
+ *
+ * Useful for periodic recalculation of all mandate statuses.
+ *
+ * @param entries - Map of mandate IDs to entries
+ * @param scores - Map of mandate IDs to scores
+ * @param config - Threshold configuration (optional)
+ * @returns Array of promotion results
+ */
+export declare function evaluateBatchPromotions(entries: Map<string, MandateEntry>, scores: Map<string, MandateScore>, config?: MandateDecayConfig): PromotionResult[];
+/**
+ * Get entries that changed status (promoted or demoted)
+ *
+ * Useful for filtering batch results to only show changes.
+ *
+ * @param results - Promotion results
+ * @returns Only the results where status changed
+ */
+export declare function getStatusChanges(results: PromotionResult[]): PromotionResult[];
+/**
+ * Group promotion results by status transition
+ *
+ * Useful for analytics and reporting.
+ *
+ * @param results - Promotion results
+ * @returns Map of transition keys (e.g., "candidate→established") to results
+ */
+export declare function groupByTransition(results: PromotionResult[]): Map<string, PromotionResult[]>;
+//# sourceMappingURL=mandate-promotion.d.ts.map

package/dist/mandate-promotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mandate-promotion.d.ts","sourceRoot":"","sources":["../src/mandate-promotion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,aAAa,EACd,MAAM,mBAAmB,CAAC;AAM3B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,2BAA2B;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,eAAe,EAAE,aAAa,CAAC;IAC/B,8BAA8B;IAC9B,UAAU,EAAE,aAAa,CAAC;IAC1B,uBAAuB;IACvB,KAAK,EAAE,YAAY,CAAC;IACpB,6BAA6B;IAC7B,QAAQ,EAAE,OAAO,CAAC;IAClB,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;CAChB;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,YAAY,EACnB,aAAa,EAAE,aAAa,EAC5B,MAAM,GAAE,kBAAiD,GACxD,aAAa,CAmCf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,YAAY,EACnB,MAAM,GAAE,kBAAiD,GACxD,eAAe,CAkCjB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAMrE;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAClC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACjC,MAAM,GAAE,kBAAiD,GACxD,eAAe,EAAE,CAenB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,eAAe,EAAE,GACzB,eAAe,EAAE,CAEnB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,eAAe,EAAE,GACzB,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAiBhC"}

package/dist/mandate-storage.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Mandate Storage Module - Persistent storage for agent voting system
+ *
+ * Provides unified storage interface for mandate entries and votes:
+ * - semantic-memory (default) - Persistent with semantic search
+ * - in-memory - For testing and ephemeral sessions
+ *
+ * Collections:
+ * - `swarm-mandates` - Mandate entry storage
+ * - `swarm-votes` - Vote storage
+ *
+ * Score calculation uses 90-day half-life decay matching learning.ts patterns.
+ *
+ * @example
+ * ```typescript
+ * // Use default semantic-memory storage
+ * const storage = createMandateStorage();
+ *
+ * // Or in-memory for testing
+ * const storage = createMandateStorage({ backend: "memory" });
+ *
+ * // Store a mandate
+ * await storage.store({
+ *   id: "mandate-123",
+ *   content: "Always use Effect for async operations",
+ *   content_type: "tip",
+ *   author_agent: "BlueLake",
+ *   created_at: new Date().toISOString(),
+ *   status: "candidate",
+ *   tags: ["async", "effect"]
+ * });
+ *
+ * // Cast a vote
+ * await storage.vote({
+ *   id: "vote-456",
+ *   mandate_id: "mandate-123",
+ *   agent_name: "BlueLake",
+ *   vote_type: "upvote",
+ *   timestamp: new Date().toISOString(),
+ *   weight: 1.0
+ * });
+ *
+ * // Calculate score with decay
+ * const score = await storage.calculateScore("mandate-123");
+ * ```
+ */
+import type { MandateEntry, Vote, MandateScore, MandateStatus, MandateContentType, MandateDecayConfig, ScoreCalculationResult } from "./schemas/mandate";
+/**
+ * Reset the cached command (for testing)
+ */
+export declare function resetCommandCache(): void;
+/**
+ * Storage backend type
+ */
+export type MandateStorageBackend = "semantic-memory" | "memory";
+/**
+ * Collection names for semantic-memory
+ */
+export interface MandateStorageCollections {
+    mandates: string;
+    votes: string;
+}
+/**
+ * Storage configuration
+ */
+export interface MandateStorageConfig {
+    /** Backend to use (default: "semantic-memory") */
+    backend: MandateStorageBackend;
+    /** Collection names for semantic-memory backend */
+    collections: MandateStorageCollections;
+    /** Decay configuration */
+    decay: MandateDecayConfig;
+    /** Whether to use semantic search for queries (default: true) */
+    useSemanticSearch: boolean;
+}
+export declare const DEFAULT_MANDATE_STORAGE_CONFIG: MandateStorageConfig;
+/**
+ * Unified storage interface for mandate data
+ */
+export interface MandateStorage {
+    store(entry: MandateEntry): Promise<void>;
+    get(id: string): Promise<MandateEntry | null>;
+    find(query: string, limit?: number): Promise<MandateEntry[]>;
+    list(filter?: {
+        status?: MandateStatus;
+        content_type?: MandateContentType;
+    }): Promise<MandateEntry[]>;
+    update(id: string, updates: Partial<MandateEntry>): Promise<void>;
+    vote(vote: Vote): Promise<void>;
+    getVotes(mandateId: string): Promise<Vote[]>;
+    hasVoted(mandateId: string, agentName: string): Promise<boolean>;
+    calculateScore(mandateId: string): Promise<MandateScore>;
+    close(): Promise<void>;
+}
+/**
+ * Semantic-memory backed mandate storage
+ *
+ * Uses the semantic-memory CLI for persistence with semantic search.
+ * Data survives across sessions and can be searched by meaning.
+ */
+export declare class SemanticMemoryMandateStorage implements MandateStorage {
+    private config;
+    constructor(config?: Partial<MandateStorageConfig>);
+    private storeInternal;
+    private findInternal;
+    private listInternal;
+    store(entry: MandateEntry): Promise<void>;
+    get(id: string): Promise<MandateEntry | null>;
+    find(query: string, limit?: number): Promise<MandateEntry[]>;
+    list(filter?: {
+        status?: MandateStatus;
+        content_type?: MandateContentType;
+    }): Promise<MandateEntry[]>;
+    update(id: string, updates: Partial<MandateEntry>): Promise<void>;
+    vote(vote: Vote): Promise<void>;
+    getVotes(mandateId: string): Promise<Vote[]>;
+    hasVoted(mandateId: string, agentName: string): Promise<boolean>;
+    calculateScore(mandateId: string): Promise<MandateScore>;
+    close(): Promise<void>;
+}
+/**
+ * In-memory mandate storage
+ *
+ * Useful for testing and ephemeral sessions.
+ */
+export declare class InMemoryMandateStorage implements MandateStorage {
+    private entries;
+    private votes;
+    private config;
+    constructor(config?: Partial<MandateStorageConfig>);
+    store(entry: MandateEntry): Promise<void>;
+    get(id: string): Promise<MandateEntry | null>;
+    find(query: string, limit?: number): Promise<MandateEntry[]>;
+    list(filter?: {
+        status?: MandateStatus;
+        content_type?: MandateContentType;
+    }): Promise<MandateEntry[]>;
+    update(id: string, updates: Partial<MandateEntry>): Promise<void>;
+    vote(vote: Vote): Promise<void>;
+    getVotes(mandateId: string): Promise<Vote[]>;
+    hasVoted(mandateId: string, agentName: string): Promise<boolean>;
+    calculateScore(mandateId: string): Promise<MandateScore>;
+    close(): Promise<void>;
+}
+/**
+ * Create a mandate storage instance
+ *
+ * @param config - Storage configuration (default: semantic-memory)
+ * @returns Configured storage instance
+ *
+ * @example
+ * ```typescript
+ * // Default semantic-memory storage
+ * const storage = createMandateStorage();
+ *
+ * // In-memory for testing
+ * const storage = createMandateStorage({ backend: "memory" });
+ *
+ * // Custom collections
+ * const storage = createMandateStorage({
+ *   backend: "semantic-memory",
+ *   collections: {
+ *     mandates: "my-mandates",
+ *     votes: "my-votes",
+ *   },
+ * });
+ * ```
+ */
+export declare function createMandateStorage(config?: Partial<MandateStorageConfig>): MandateStorage;
+/**
+ * Update mandate status based on calculated score
+ *
+ * Applies thresholds from decay config to determine status transitions:
+ * - mandate: net_votes >= 5 AND vote_ratio >= 0.7
+ * - established: net_votes >= 2
+ * - rejected: net_votes <= -3
+ * - candidate: otherwise
+ *
+ * @param mandateId - Mandate ID
+ * @param storage - Storage instance
+ * @returns Score calculation result with status update
+ */
+export declare function updateMandateStatus(mandateId: string, storage: MandateStorage): Promise<ScoreCalculationResult>;
+/**
+ * Batch update all mandate statuses
+ *
+ * Useful for periodic recalculation of scores/status across all mandates.
+ *
+ * @param storage - Storage instance
+ * @returns Array of score calculation results
+ */
+export declare function updateAllMandateStatuses(storage: MandateStorage): Promise<ScoreCalculationResult[]>;
+/**
+ * Get or create the global mandate storage instance
+ *
+ * Uses semantic-memory by default.
+ */
+export declare function getMandateStorage(): MandateStorage;
+/**
+ * Set the global mandate storage instance
+ *
+ * Useful for testing or custom configurations.
+ */
+export declare function setMandateStorage(storage: MandateStorage): void;
+/**
+ * Reset the global mandate storage instance
+ */
+export declare function resetMandateStorage(): Promise<void>;
+//# sourceMappingURL=mandate-storage.d.ts.map

package/dist/mandate-storage.d.ts.map

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

package/dist/mandates.d.ts

@@ -0,0 +1,230 @@
+export declare class MandateError extends Error {
+    readonly operation: string;
+    readonly details?: unknown | undefined;
+    constructor(message: string, operation: string, details?: unknown | undefined);
+}
+/**
+ * Submit a new mandate entry
+ *
+ * Creates a new entry in the mandate system for voting.
+ * Entries start in "candidate" status and can be promoted based on votes.
+ */
+export declare const mandate_file: {
+    description: string;
+    args: {
+        content: import("zod").ZodString;
+        content_type: import("zod").ZodEnum<{
+            idea: "idea";
+            tip: "tip";
+            lore: "lore";
+            snippet: "snippet";
+            feature_request: "feature_request";
+        }>;
+        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    };
+    execute(args: {
+        content: string;
+        content_type: "idea" | "tip" | "lore" | "snippet" | "feature_request";
+        tags?: string[] | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Cast a vote on an existing mandate
+ *
+ * Each agent can vote once per mandate. Duplicate votes are rejected.
+ * Votes influence mandate status through consensus scoring.
+ */
+export declare const mandate_vote: {
+    description: string;
+    args: {
+        mandate_id: import("zod").ZodString;
+        vote_type: import("zod").ZodEnum<{
+            upvote: "upvote";
+            downvote: "downvote";
+        }>;
+        agent_name: import("zod").ZodString;
+    };
+    execute(args: {
+        mandate_id: string;
+        vote_type: "upvote" | "downvote";
+        agent_name: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Search for relevant mandates using semantic search
+ *
+ * Queries the mandate system by meaning, not just keywords.
+ * Useful for finding past decisions or patterns related to a topic.
+ */
+export declare const mandate_query: {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        status: import("zod").ZodOptional<import("zod").ZodEnum<{
+            candidate: "candidate";
+            established: "established";
+            mandate: "mandate";
+            rejected: "rejected";
+        }>>;
+        content_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+            idea: "idea";
+            tip: "tip";
+            lore: "lore";
+            snippet: "snippet";
+            feature_request: "feature_request";
+        }>>;
+    };
+    execute(args: {
+        query: string;
+        limit?: number | undefined;
+        status?: "candidate" | "established" | "mandate" | "rejected" | undefined;
+        content_type?: "idea" | "tip" | "lore" | "snippet" | "feature_request" | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * List mandates with optional filters
+ *
+ * Retrieves mandates by status, content type, or both.
+ * Does not use semantic search - returns all matching mandates.
+ */
+export declare const mandate_list: {
+    description: string;
+    args: {
+        status: import("zod").ZodOptional<import("zod").ZodEnum<{
+            candidate: "candidate";
+            established: "established";
+            mandate: "mandate";
+            rejected: "rejected";
+        }>>;
+        content_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+            idea: "idea";
+            tip: "tip";
+            lore: "lore";
+            snippet: "snippet";
+            feature_request: "feature_request";
+        }>>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        status?: "candidate" | "established" | "mandate" | "rejected" | undefined;
+        content_type?: "idea" | "tip" | "lore" | "snippet" | "feature_request" | undefined;
+        limit?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Get voting statistics for a mandate or overall system
+ *
+ * If mandate_id is provided, returns detailed stats for that mandate.
+ * Otherwise, returns aggregate stats across all mandates.
+ */
+export declare const mandate_stats: {
+    description: string;
+    args: {
+        mandate_id: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        mandate_id?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const mandateTools: {
+    mandate_file: {
+        description: string;
+        args: {
+            content: import("zod").ZodString;
+            content_type: import("zod").ZodEnum<{
+                idea: "idea";
+                tip: "tip";
+                lore: "lore";
+                snippet: "snippet";
+                feature_request: "feature_request";
+            }>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        };
+        execute(args: {
+            content: string;
+            content_type: "idea" | "tip" | "lore" | "snippet" | "feature_request";
+            tags?: string[] | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    mandate_vote: {
+        description: string;
+        args: {
+            mandate_id: import("zod").ZodString;
+            vote_type: import("zod").ZodEnum<{
+                upvote: "upvote";
+                downvote: "downvote";
+            }>;
+            agent_name: import("zod").ZodString;
+        };
+        execute(args: {
+            mandate_id: string;
+            vote_type: "upvote" | "downvote";
+            agent_name: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    mandate_query: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                candidate: "candidate";
+                established: "established";
+                mandate: "mandate";
+                rejected: "rejected";
+            }>>;
+            content_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                idea: "idea";
+                tip: "tip";
+                lore: "lore";
+                snippet: "snippet";
+                feature_request: "feature_request";
+            }>>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+            status?: "candidate" | "established" | "mandate" | "rejected" | undefined;
+            content_type?: "idea" | "tip" | "lore" | "snippet" | "feature_request" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    mandate_list: {
+        description: string;
+        args: {
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                candidate: "candidate";
+                established: "established";
+                mandate: "mandate";
+                rejected: "rejected";
+            }>>;
+            content_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                idea: "idea";
+                tip: "tip";
+                lore: "lore";
+                snippet: "snippet";
+                feature_request: "feature_request";
+            }>>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            status?: "candidate" | "established" | "mandate" | "rejected" | undefined;
+            content_type?: "idea" | "tip" | "lore" | "snippet" | "feature_request" | undefined;
+            limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    mandate_stats: {
+        description: string;
+        args: {
+            mandate_id: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            mandate_id?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=mandates.d.ts.map

package/dist/mandates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mandates.d.ts","sourceRoot":"","sources":["../src/mandates.ts"],"names":[],"mappings":"AAuCA,qBAAa,YAAa,SAAQ,KAAK;aAGnB,SAAS,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,YAAA;CAKpC;AAgCD;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;CA6DvB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;CA6FvB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;CAkFxB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;CA8EvB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;CA+FxB,CAAC;AAMH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMxB,CAAC"}

package/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/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,eA6EtC,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"}