@claude-flow/plugin-gastown-bridge 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4688 @@
+import { EventEmitter } from 'events';
+import { z } from 'zod';
+import { GtBridge, BdBridge, SyncBridge } from './bridges.js';
+export { AddressSchema, AgentDBEntry, AgentDBEntrySchema, BdArgumentSchema, BdBridgeConfig, BdBridgeError, BdErrorCode, BdLogger, BdResult, BdStreamResult, BeadIdSchema, BeadQuery, CliBead, CliBeadSchema, CliBeadType, CliBeadTypeSchema, CliSyncDirection, CliSyncDirectionSchema, CliSyncResult, ConflictStrategy, ConflictStrategySchema, CreateBeadParams, GasEstimate, GasLimitSchema, GasPriceSchema, GtArgumentSchema, GtBridgeConfig, GtBridgeError, GtErrorCode, GtIdentifierSchema, GtLogger, GtResult, GtSafeStringSchema, IAgentDBService, NetworkSchema, NetworkStatus, SyncBridgeConfig, SyncBridgeError, SyncConflict, SyncErrorCode, SyncLogger, SyncState, SyncStatus, SyncStatusSchema, TxHashSchema, TxStatus, createBdBridge, createGtBridge, createSyncBridge } from './bridges.js';
+import 'child_process';
+
+/**
+ * Gas Town Bridge Plugin - Type Definitions
+ *
+ * Core types for Gas Town integration including:
+ * - Beads: Git-backed issue tracking with graph semantics
+ * - Formulas: TOML-defined workflows (convoy, workflow, expansion, aspect)
+ * - Convoys: Work-order tracking for slung work
+ * - Steps/Legs: Workflow components
+ * - Variables: Template substitution
+ *
+ * @module gastown-bridge/types
+ * @version 0.1.0
+ */
+
+/**
+ * Bead status enumeration
+ */
+type BeadStatus = 'open' | 'in_progress' | 'closed';
+/**
+ * Bead - Git-backed issue with graph semantics
+ */
+interface Bead {
+    /** Unique identifier (e.g., "gt-abc12") */
+    readonly id: string;
+    /** Issue title */
+    readonly title: string;
+    /** Issue description */
+    readonly description: string;
+    /** Current status */
+    readonly status: BeadStatus;
+    /** Priority (0 = highest) */
+    readonly priority: number;
+    /** Issue labels */
+    readonly labels: string[];
+    /** Parent bead ID (for epics) */
+    readonly parentId?: string;
+    /** Creation timestamp */
+    readonly createdAt: Date;
+    /** Last update timestamp */
+    readonly updatedAt: Date;
+    /** Assigned agent/user */
+    readonly assignee?: string;
+    /** Gas Town rig name */
+    readonly rig?: string;
+    /** Blocking beads (dependencies) */
+    readonly blockedBy?: string[];
+    /** Beads this blocks */
+    readonly blocks?: string[];
+}
+/**
+ * Options for creating a new bead
+ */
+interface CreateBeadOptions {
+    readonly title: string;
+    readonly description?: string;
+    readonly priority?: number;
+    readonly labels?: string[];
+    readonly parent?: string;
+    readonly rig?: string;
+    readonly assignee?: string;
+}
+/**
+ * Bead dependency relationship
+ */
+interface BeadDependency {
+    readonly child: string;
+    readonly parent: string;
+    readonly type: 'blocks' | 'relates' | 'duplicates';
+}
+/**
+ * Formula type enumeration
+ */
+type FormulaType = 'convoy' | 'workflow' | 'expansion' | 'aspect';
+/**
+ * Workflow step definition
+ */
+interface Step {
+    /** Step identifier */
+    readonly id: string;
+    /** Step title */
+    readonly title: string;
+    /** Step description */
+    readonly description: string;
+    /** Dependencies - step IDs that must complete first */
+    readonly needs?: string[];
+    /** Estimated duration in minutes */
+    readonly duration?: number;
+    /** Required capabilities */
+    readonly requires?: string[];
+    /** Step metadata */
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * Convoy leg definition
+ */
+interface Leg {
+    /** Leg identifier */
+    readonly id: string;
+    /** Leg title */
+    readonly title: string;
+    /** Focus area */
+    readonly focus: string;
+    /** Leg description */
+    readonly description: string;
+    /** Assigned agent type */
+    readonly agent?: string;
+    /** Leg sequence order */
+    readonly order?: number;
+}
+/**
+ * Formula variable definition
+ */
+interface Var {
+    /** Variable name */
+    readonly name: string;
+    /** Variable description */
+    readonly description?: string;
+    /** Default value */
+    readonly default?: string;
+    /** Whether the variable is required */
+    readonly required?: boolean;
+    /** Validation pattern (regex) */
+    readonly pattern?: string;
+    /** Allowed values */
+    readonly enum?: string[];
+}
+/**
+ * Synthesis definition (convoy result combination)
+ */
+interface Synthesis {
+    /** Synthesis strategy */
+    readonly strategy: 'merge' | 'sequential' | 'parallel';
+    /** Output format */
+    readonly format?: string;
+    /** Synthesis description */
+    readonly description?: string;
+}
+/**
+ * Template for expansion formulas
+ */
+interface Template {
+    /** Template name */
+    readonly name: string;
+    /** Template content with variable placeholders */
+    readonly content: string;
+    /** Output path pattern */
+    readonly outputPath?: string;
+}
+/**
+ * Aspect definition for cross-cutting concerns
+ */
+interface Aspect {
+    /** Aspect name */
+    readonly name: string;
+    /** Pointcut expression */
+    readonly pointcut: string;
+    /** Advice to apply */
+    readonly advice: string;
+    /** Aspect type */
+    readonly type: 'before' | 'after' | 'around';
+}
+/**
+ * Formula - TOML-defined workflow specification
+ */
+interface Formula {
+    /** Formula name */
+    readonly name: string;
+    /** Formula description */
+    readonly description: string;
+    /** Formula type */
+    readonly type: FormulaType;
+    /** Formula version */
+    readonly version: number;
+    /** Convoy legs */
+    readonly legs?: Leg[];
+    /** Synthesis configuration */
+    readonly synthesis?: Synthesis;
+    /** Workflow steps */
+    readonly steps?: Step[];
+    /** Variable definitions */
+    readonly vars?: Record<string, Var>;
+    /** Expansion templates */
+    readonly templates?: Template[];
+    /** Cross-cutting aspects */
+    readonly aspects?: Aspect[];
+    /** Formula metadata */
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * Cooked formula with variables substituted
+ */
+interface CookedFormula extends Formula {
+    /** When the formula was cooked */
+    readonly cookedAt: Date;
+    /** Variables used for cooking */
+    readonly cookedVars: Record<string, string>;
+    /** Original (uncooked) formula name */
+    readonly originalName: string;
+}
+/**
+ * Convoy status enumeration
+ */
+type ConvoyStatus = 'active' | 'landed' | 'failed' | 'paused';
+/**
+ * Convoy progress tracking
+ */
+interface ConvoyProgress {
+    /** Total issues tracked */
+    readonly total: number;
+    /** Closed issues */
+    readonly closed: number;
+    /** In-progress issues */
+    readonly inProgress: number;
+    /** Blocked issues */
+    readonly blocked: number;
+}
+/**
+ * Convoy - Work order tracking for slung work
+ */
+interface Convoy {
+    /** Convoy identifier */
+    readonly id: string;
+    /** Convoy name */
+    readonly name: string;
+    /** Tracked issue IDs */
+    readonly trackedIssues: string[];
+    /** Convoy status */
+    readonly status: ConvoyStatus;
+    /** Start timestamp */
+    readonly startedAt: Date;
+    /** Completion timestamp */
+    readonly completedAt?: Date;
+    /** Progress tracking */
+    readonly progress: ConvoyProgress;
+    /** Formula used to create convoy */
+    readonly formula?: string;
+    /** Description */
+    readonly description?: string;
+}
+/**
+ * Options for creating a convoy
+ */
+interface CreateConvoyOptions {
+    readonly name: string;
+    readonly issues: string[];
+    readonly description?: string;
+    readonly formula?: string;
+}
+/**
+ * Gas Town agent role
+ */
+type GasTownAgentRole = 'mayor' | 'polecat' | 'refinery' | 'witness' | 'deacon' | 'dog' | 'crew';
+/**
+ * Gas Town agent
+ */
+interface GasTownAgent {
+    /** Agent name */
+    readonly name: string;
+    /** Agent role */
+    readonly role: GasTownAgentRole;
+    /** Rig assignment */
+    readonly rig?: string;
+    /** Current status */
+    readonly status: 'active' | 'idle' | 'busy';
+    /** Agent capabilities */
+    readonly capabilities?: string[];
+}
+/**
+ * Sling target type
+ */
+type SlingTarget = 'polecat' | 'crew' | 'mayor';
+/**
+ * Sling operation options
+ */
+interface SlingOptions {
+    readonly beadId: string;
+    readonly target: SlingTarget;
+    readonly formula?: string;
+    readonly priority?: number;
+}
+/**
+ * Gas Town mail message
+ */
+interface GasTownMail {
+    readonly id: string;
+    readonly from: string;
+    readonly to: string;
+    readonly subject: string;
+    readonly body: string;
+    readonly sentAt: Date;
+    readonly read: boolean;
+}
+/**
+ * Sync direction
+ */
+type SyncDirection = 'pull' | 'push' | 'both';
+/**
+ * Sync result
+ */
+interface SyncResult {
+    readonly direction: SyncDirection;
+    readonly pulled: number;
+    readonly pushed: number;
+    readonly errors: string[];
+    readonly timestamp: Date;
+}
+/**
+ * Dependency graph for beads
+ */
+interface BeadGraph {
+    readonly nodes: string[];
+    readonly edges: Array<[string, string]>;
+}
+/**
+ * Topological sort result
+ */
+interface TopoSortResult {
+    readonly sorted: string[];
+    readonly hasCycle: boolean;
+    readonly cycleNodes?: string[];
+}
+/**
+ * Critical path result
+ */
+interface CriticalPathResult {
+    readonly path: string[];
+    readonly totalDuration: number;
+    readonly slack: Map<string, number>;
+}
+/**
+ * Gas Town Bridge plugin configuration
+ */
+interface GasTownConfig {
+    /** Path to Gas Town installation */
+    readonly townRoot: string;
+    /** Enable Beads sync with AgentDB */
+    readonly enableBeadsSync: boolean;
+    /** Sync interval in milliseconds */
+    readonly syncInterval: number;
+    /** Enable native formula parsing (WASM) */
+    readonly nativeFormulas: boolean;
+    /** Enable convoy tracking */
+    readonly enableConvoys: boolean;
+    /** Auto-create beads from Claude Flow tasks */
+    readonly autoCreateBeads: boolean;
+    /** Enable GUPP integration */
+    readonly enableGUPP: boolean;
+    /** GUPP check interval in milliseconds */
+    readonly guppCheckInterval: number;
+    /** CLI timeout in milliseconds */
+    readonly cliTimeout: number;
+}
+/**
+ * Default configuration values
+ */
+declare const DEFAULT_CONFIG: GasTownConfig;
+/**
+ * Gas Town Bridge error codes
+ */
+declare const GasTownErrorCodes: {
+    readonly CLI_NOT_FOUND: "GT_CLI_NOT_FOUND";
+    readonly CLI_TIMEOUT: "GT_CLI_TIMEOUT";
+    readonly CLI_ERROR: "GT_CLI_ERROR";
+    readonly BEAD_NOT_FOUND: "GT_BEAD_NOT_FOUND";
+    readonly CONVOY_NOT_FOUND: "GT_CONVOY_NOT_FOUND";
+    readonly FORMULA_NOT_FOUND: "GT_FORMULA_NOT_FOUND";
+    readonly FORMULA_PARSE_ERROR: "GT_FORMULA_PARSE_ERROR";
+    readonly WASM_NOT_INITIALIZED: "GT_WASM_NOT_INITIALIZED";
+    readonly SYNC_ERROR: "GT_SYNC_ERROR";
+    readonly DEPENDENCY_CYCLE: "GT_DEPENDENCY_CYCLE";
+    readonly INVALID_SLING_TARGET: "GT_INVALID_SLING_TARGET";
+};
+type GasTownErrorCode$1 = (typeof GasTownErrorCodes)[keyof typeof GasTownErrorCodes];
+/**
+ * Bead status schema
+ */
+declare const BeadStatusSchema: z.ZodEnum<["open", "in_progress", "closed"]>;
+/**
+ * Bead schema
+ */
+declare const BeadSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<["open", "in_progress", "closed"]>;
+    priority: z.ZodNumber;
+    labels: z.ZodArray<z.ZodString, "many">;
+    parentId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    assignee: z.ZodOptional<z.ZodString>;
+    rig: z.ZodOptional<z.ZodString>;
+    blockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    id: string;
+    status: "open" | "in_progress" | "closed";
+    createdAt: Date;
+    updatedAt: Date;
+    priority: number;
+    title: string;
+    labels: string[];
+    parentId?: string | undefined;
+    assignee?: string | undefined;
+    rig?: string | undefined;
+    blockedBy?: string[] | undefined;
+    blocks?: string[] | undefined;
+}, {
+    description: string;
+    id: string;
+    status: "open" | "in_progress" | "closed";
+    createdAt: Date;
+    updatedAt: Date;
+    priority: number;
+    title: string;
+    labels: string[];
+    parentId?: string | undefined;
+    assignee?: string | undefined;
+    rig?: string | undefined;
+    blockedBy?: string[] | undefined;
+    blocks?: string[] | undefined;
+}>;
+/**
+ * Create bead options schema
+ */
+declare const CreateBeadOptionsSchema$1: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    parent: z.ZodOptional<z.ZodString>;
+    rig: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description?: string | undefined;
+    priority?: number | undefined;
+    assignee?: string | undefined;
+    labels?: string[] | undefined;
+    rig?: string | undefined;
+    parent?: string | undefined;
+}, {
+    title: string;
+    description?: string | undefined;
+    priority?: number | undefined;
+    assignee?: string | undefined;
+    labels?: string[] | undefined;
+    rig?: string | undefined;
+    parent?: string | undefined;
+}>;
+/**
+ * Formula type schema
+ */
+declare const FormulaTypeSchema: z.ZodEnum<["convoy", "workflow", "expansion", "aspect"]>;
+/**
+ * Step schema
+ */
+declare const StepSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    needs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    id: string;
+    title: string;
+    metadata?: Record<string, unknown> | undefined;
+    needs?: string[] | undefined;
+    duration?: number | undefined;
+    requires?: string[] | undefined;
+}, {
+    description: string;
+    id: string;
+    title: string;
+    metadata?: Record<string, unknown> | undefined;
+    needs?: string[] | undefined;
+    duration?: number | undefined;
+    requires?: string[] | undefined;
+}>;
+/**
+ * Leg schema
+ */
+declare const LegSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    focus: z.ZodString;
+    description: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    id: string;
+    title: string;
+    focus: string;
+    agent?: string | undefined;
+    order?: number | undefined;
+}, {
+    description: string;
+    id: string;
+    title: string;
+    focus: string;
+    agent?: string | undefined;
+    order?: number | undefined;
+}>;
+/**
+ * Variable schema
+ */
+declare const VarSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    pattern: z.ZodOptional<z.ZodString>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description?: string | undefined;
+    default?: string | undefined;
+    required?: boolean | undefined;
+    pattern?: string | undefined;
+    enum?: string[] | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+    default?: string | undefined;
+    required?: boolean | undefined;
+    pattern?: string | undefined;
+    enum?: string[] | undefined;
+}>;
+/**
+ * Synthesis schema
+ */
+declare const SynthesisSchema: z.ZodObject<{
+    strategy: z.ZodEnum<["merge", "sequential", "parallel"]>;
+    format: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "parallel" | "merge" | "sequential";
+    description?: string | undefined;
+    format?: string | undefined;
+}, {
+    strategy: "parallel" | "merge" | "sequential";
+    description?: string | undefined;
+    format?: string | undefined;
+}>;
+/**
+ * Template schema
+ */
+declare const TemplateSchema: z.ZodObject<{
+    name: z.ZodString;
+    content: z.ZodString;
+    outputPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    content: string;
+    outputPath?: string | undefined;
+}, {
+    name: string;
+    content: string;
+    outputPath?: string | undefined;
+}>;
+/**
+ * Aspect schema
+ */
+declare const AspectSchema: z.ZodObject<{
+    name: z.ZodString;
+    pointcut: z.ZodString;
+    advice: z.ZodString;
+    type: z.ZodEnum<["before", "after", "around"]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "before" | "after" | "around";
+    pointcut: string;
+    advice: string;
+}, {
+    name: string;
+    type: "before" | "after" | "around";
+    pointcut: string;
+    advice: string;
+}>;
+/**
+ * Formula schema
+ */
+declare const FormulaSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<["convoy", "workflow", "expansion", "aspect"]>;
+    version: z.ZodNumber;
+    legs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        focus: z.ZodString;
+        description: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        id: string;
+        title: string;
+        focus: string;
+        agent?: string | undefined;
+        order?: number | undefined;
+    }, {
+        description: string;
+        id: string;
+        title: string;
+        focus: string;
+        agent?: string | undefined;
+        order?: number | undefined;
+    }>, "many">>;
+    synthesis: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodEnum<["merge", "sequential", "parallel"]>;
+        format: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "parallel" | "merge" | "sequential";
+        description?: string | undefined;
+        format?: string | undefined;
+    }, {
+        strategy: "parallel" | "merge" | "sequential";
+        description?: string | undefined;
+        format?: string | undefined;
+    }>>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        needs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        requires: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        id: string;
+        title: string;
+        metadata?: Record<string, unknown> | undefined;
+        needs?: string[] | undefined;
+        duration?: number | undefined;
+        requires?: string[] | undefined;
+    }, {
+        description: string;
+        id: string;
+        title: string;
+        metadata?: Record<string, unknown> | undefined;
+        needs?: string[] | undefined;
+        duration?: number | undefined;
+        requires?: string[] | undefined;
+    }>, "many">>;
+    vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        pattern: z.ZodOptional<z.ZodString>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        default?: string | undefined;
+        required?: boolean | undefined;
+        pattern?: string | undefined;
+        enum?: string[] | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        default?: string | undefined;
+        required?: boolean | undefined;
+        pattern?: string | undefined;
+        enum?: string[] | undefined;
+    }>>>;
+    templates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        content: z.ZodString;
+        outputPath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        content: string;
+        outputPath?: string | undefined;
+    }, {
+        name: string;
+        content: string;
+        outputPath?: string | undefined;
+    }>, "many">>;
+    aspects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        pointcut: z.ZodString;
+        advice: z.ZodString;
+        type: z.ZodEnum<["before", "after", "around"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "before" | "after" | "around";
+        pointcut: string;
+        advice: string;
+    }, {
+        name: string;
+        type: "before" | "after" | "around";
+        pointcut: string;
+        advice: string;
+    }>, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    type: "convoy" | "workflow" | "expansion" | "aspect";
+    version: number;
+    steps?: {
+        description: string;
+        id: string;
+        title: string;
+        metadata?: Record<string, unknown> | undefined;
+        needs?: string[] | undefined;
+        duration?: number | undefined;
+        requires?: string[] | undefined;
+    }[] | undefined;
+    legs?: {
+        description: string;
+        id: string;
+        title: string;
+        focus: string;
+        agent?: string | undefined;
+        order?: number | undefined;
+    }[] | undefined;
+    vars?: Record<string, {
+        name: string;
+        description?: string | undefined;
+        default?: string | undefined;
+        required?: boolean | undefined;
+        pattern?: string | undefined;
+        enum?: string[] | undefined;
+    }> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    synthesis?: {
+        strategy: "parallel" | "merge" | "sequential";
+        description?: string | undefined;
+        format?: string | undefined;
+    } | undefined;
+    templates?: {
+        name: string;
+        content: string;
+        outputPath?: string | undefined;
+    }[] | undefined;
+    aspects?: {
+        name: string;
+        type: "before" | "after" | "around";
+        pointcut: string;
+        advice: string;
+    }[] | undefined;
+}, {
+    name: string;
+    description: string;
+    type: "convoy" | "workflow" | "expansion" | "aspect";
+    version: number;
+    steps?: {
+        description: string;
+        id: string;
+        title: string;
+        metadata?: Record<string, unknown> | undefined;
+        needs?: string[] | undefined;
+        duration?: number | undefined;
+        requires?: string[] | undefined;
+    }[] | undefined;
+    legs?: {
+        description: string;
+        id: string;
+        title: string;
+        focus: string;
+        agent?: string | undefined;
+        order?: number | undefined;
+    }[] | undefined;
+    vars?: Record<string, {
+        name: string;
+        description?: string | undefined;
+        default?: string | undefined;
+        required?: boolean | undefined;
+        pattern?: string | undefined;
+        enum?: string[] | undefined;
+    }> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    synthesis?: {
+        strategy: "parallel" | "merge" | "sequential";
+        description?: string | undefined;
+        format?: string | undefined;
+    } | undefined;
+    templates?: {
+        name: string;
+        content: string;
+        outputPath?: string | undefined;
+    }[] | undefined;
+    aspects?: {
+        name: string;
+        type: "before" | "after" | "around";
+        pointcut: string;
+        advice: string;
+    }[] | undefined;
+}>;
+/**
+ * Convoy status schema
+ */
+declare const ConvoyStatusSchema: z.ZodEnum<["active", "landed", "failed", "paused"]>;
+/**
+ * Convoy progress schema
+ */
+declare const ConvoyProgressSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    closed: z.ZodNumber;
+    inProgress: z.ZodNumber;
+    blocked: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    closed: number;
+    total: number;
+    inProgress: number;
+    blocked: number;
+}, {
+    closed: number;
+    total: number;
+    inProgress: number;
+    blocked: number;
+}>;
+/**
+ * Convoy schema
+ */
+declare const ConvoySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    trackedIssues: z.ZodArray<z.ZodString, "many">;
+    status: z.ZodEnum<["active", "landed", "failed", "paused"]>;
+    startedAt: z.ZodDate;
+    completedAt: z.ZodOptional<z.ZodDate>;
+    progress: z.ZodObject<{
+        total: z.ZodNumber;
+        closed: z.ZodNumber;
+        inProgress: z.ZodNumber;
+        blocked: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        closed: number;
+        total: number;
+        inProgress: number;
+        blocked: number;
+    }, {
+        closed: number;
+        total: number;
+        inProgress: number;
+        blocked: number;
+    }>;
+    formula: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    status: "active" | "landed" | "failed" | "paused";
+    trackedIssues: string[];
+    startedAt: Date;
+    progress: {
+        closed: number;
+        total: number;
+        inProgress: number;
+        blocked: number;
+    };
+    description?: string | undefined;
+    completedAt?: Date | undefined;
+    formula?: string | undefined;
+}, {
+    name: string;
+    id: string;
+    status: "active" | "landed" | "failed" | "paused";
+    trackedIssues: string[];
+    startedAt: Date;
+    progress: {
+        closed: number;
+        total: number;
+        inProgress: number;
+        blocked: number;
+    };
+    description?: string | undefined;
+    completedAt?: Date | undefined;
+    formula?: string | undefined;
+}>;
+/**
+ * Create convoy options schema
+ */
+declare const CreateConvoyOptionsSchema$1: z.ZodObject<{
+    name: z.ZodString;
+    issues: z.ZodArray<z.ZodString, "many">;
+    description: z.ZodOptional<z.ZodString>;
+    formula: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    issues: string[];
+    description?: string | undefined;
+    formula?: string | undefined;
+}, {
+    name: string;
+    issues: string[];
+    description?: string | undefined;
+    formula?: string | undefined;
+}>;
+/**
+ * Gas Town agent role schema
+ */
+declare const GasTownAgentRoleSchema: z.ZodEnum<["mayor", "polecat", "refinery", "witness", "deacon", "dog", "crew"]>;
+/**
+ * Sling target schema
+ */
+declare const SlingTargetSchema: z.ZodEnum<["polecat", "crew", "mayor"]>;
+/**
+ * Sling options schema
+ */
+declare const SlingOptionsSchema$1: z.ZodObject<{
+    beadId: z.ZodString;
+    target: z.ZodEnum<["polecat", "crew", "mayor"]>;
+    formula: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    beadId: string;
+    target: "mayor" | "polecat" | "crew";
+    priority?: number | undefined;
+    formula?: string | undefined;
+}, {
+    beadId: string;
+    target: "mayor" | "polecat" | "crew";
+    priority?: number | undefined;
+    formula?: string | undefined;
+}>;
+/**
+ * Sync direction schema
+ */
+declare const SyncDirectionSchema: z.ZodEnum<["pull", "push", "both"]>;
+/**
+ * Configuration schema
+ */
+declare const GasTownConfigSchema: z.ZodObject<{
+    townRoot: z.ZodDefault<z.ZodString>;
+    enableBeadsSync: z.ZodDefault<z.ZodBoolean>;
+    syncInterval: z.ZodDefault<z.ZodNumber>;
+    nativeFormulas: z.ZodDefault<z.ZodBoolean>;
+    enableConvoys: z.ZodDefault<z.ZodBoolean>;
+    autoCreateBeads: z.ZodDefault<z.ZodBoolean>;
+    enableGUPP: z.ZodDefault<z.ZodBoolean>;
+    guppCheckInterval: z.ZodDefault<z.ZodNumber>;
+    cliTimeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    syncInterval: number;
+    townRoot: string;
+    enableBeadsSync: boolean;
+    nativeFormulas: boolean;
+    enableConvoys: boolean;
+    autoCreateBeads: boolean;
+    enableGUPP: boolean;
+    guppCheckInterval: number;
+    cliTimeout: number;
+}, {
+    syncInterval?: number | undefined;
+    townRoot?: string | undefined;
+    enableBeadsSync?: boolean | undefined;
+    nativeFormulas?: boolean | undefined;
+    enableConvoys?: boolean | undefined;
+    autoCreateBeads?: boolean | undefined;
+    enableGUPP?: boolean | undefined;
+    guppCheckInterval?: number | undefined;
+    cliTimeout?: number | undefined;
+}>;
+/**
+ * Validate bead
+ */
+declare function validateBead(input: unknown): Bead;
+/**
+ * Validate create bead options
+ */
+declare function validateCreateBeadOptions$1(input: unknown): CreateBeadOptions;
+/**
+ * Validate formula
+ */
+declare function validateFormula(input: unknown): Formula;
+/**
+ * Validate convoy
+ */
+declare function validateConvoy(input: unknown): Convoy;
+/**
+ * Validate create convoy options
+ */
+declare function validateCreateConvoyOptions$1(input: unknown): CreateConvoyOptions;
+/**
+ * Validate sling options
+ */
+declare function validateSlingOptions$1(input: unknown): SlingOptions;
+/**
+ * Validate configuration
+ */
+declare function validateConfig(input: unknown): GasTownConfig;
+/**
+ * Dependency action type
+ */
+type DepAction = 'add' | 'remove';
+/**
+ * Convoy action type
+ */
+type ConvoyAction = 'create' | 'track' | 'land' | 'pause' | 'resume';
+/**
+ * Mail action type
+ */
+type MailAction = 'send' | 'read' | 'list';
+/**
+ * Agent role type (alias for GasTownAgentRole)
+ */
+type AgentRole = GasTownAgentRole;
+/**
+ * Target agent type (alias for SlingTarget)
+ */
+type TargetAgent = SlingTarget;
+/**
+ * Convoy strategy type
+ */
+type ConvoyStrategy = 'parallel' | 'serial' | 'hybrid' | 'fastest' | 'balanced' | 'throughput' | 'minimal_context_switches';
+/**
+ * Dependency action type (for graph operations)
+ */
+type DependencyAction = 'topo_sort' | 'cycle_detect' | 'critical_path';
+/**
+ * Formula AST (Abstract Syntax Tree) - alias for Formula
+ */
+type FormulaAST = Formula;
+/**
+ * Dependency resolution result
+ */
+interface DependencyResolution {
+    readonly action: DependencyAction;
+    readonly sorted?: string[];
+    readonly hasCycle?: boolean;
+    readonly cycleNodes?: string[];
+    readonly criticalPath?: string[];
+    readonly totalDuration?: number;
+}
+/**
+ * Pattern match result
+ */
+interface PatternMatch {
+    readonly index: number;
+    readonly candidate: string;
+    readonly similarity: number;
+}
+/**
+ * Convoy optimization result
+ */
+interface ConvoyOptimization {
+    readonly convoyId: string;
+    readonly strategy: string;
+    readonly executionOrder: string[];
+    readonly parallelGroups: string[][];
+    readonly estimatedDuration: number;
+}
+/**
+ * Gas Town Bridge interface
+ */
+interface IGasTownBridge$1 {
+    createBead(opts: CreateBeadOptions): Promise<Bead>;
+    getReady(limit?: number, rig?: string, labels?: string[]): Promise<Bead[]>;
+    showBead(beadId: string): Promise<{
+        bead: Bead;
+        dependencies: string[];
+        dependents: string[];
+    }>;
+    manageDependency(action: DepAction, child: string, parent: string): Promise<void>;
+    createConvoy(opts: CreateConvoyOptions): Promise<Convoy>;
+    getConvoyStatus(convoyId?: string, detailed?: boolean): Promise<Convoy[]>;
+    trackConvoy(convoyId: string, action: 'add' | 'remove', issues: string[]): Promise<void>;
+    listFormulas(type?: FormulaType, includeBuiltin?: boolean): Promise<Array<{
+        name: string;
+        type: FormulaType;
+        description: string;
+        builtin: boolean;
+    }>>;
+    cookFormula(formula: Formula | string, vars: Record<string, string>): Promise<CookedFormula>;
+    executeFormula(formula: Formula | string, vars: Record<string, string>, targetAgent?: string, dryRun?: boolean): Promise<{
+        beads_created: string[];
+    }>;
+    createFormula(opts: {
+        name: string;
+        type: FormulaType;
+        steps?: Step[];
+        vars?: Record<string, unknown>;
+        description?: string;
+    }): Promise<{
+        path: string;
+    }>;
+    sling(beadId: string, target: SlingTarget, formula?: string, priority?: number): Promise<void>;
+    listAgents(rig?: string, role?: AgentRole, includeInactive?: boolean): Promise<GasTownAgent[]>;
+    sendMail(to: string, subject: string, body: string): Promise<string>;
+    readMail(mailId: string): Promise<GasTownMail>;
+    listMail(limit?: number): Promise<GasTownMail[]>;
+}
+/**
+ * Beads sync service interface
+ */
+interface IBeadsSyncService {
+    pullBeads(rig?: string, namespace?: string): Promise<{
+        synced: number;
+        conflicts: number;
+    }>;
+    pushTasks(namespace?: string): Promise<{
+        pushed: number;
+        conflicts: number;
+    }>;
+}
+/**
+ * Formula WASM interface
+ */
+interface IFormulaWasm {
+    isInitialized(): boolean;
+    initialize(): Promise<void>;
+    parseFormula(content: string, validate?: boolean): Promise<Formula>;
+    cookFormula(formula: Formula | string, vars: Record<string, string>, isContent?: boolean): Promise<CookedFormula>;
+    cookBatch(formulas: Array<{
+        name: string;
+        content: string;
+    }>, vars: Record<string, string>[], continueOnError?: boolean): Promise<{
+        cooked: CookedFormula[];
+        errors: Array<{
+            index: number;
+            error: string;
+        }>;
+    }>;
+}
+/**
+ * Dependency WASM interface
+ */
+interface IDependencyWasm {
+    isInitialized(): boolean;
+    initialize(): Promise<void>;
+    resolveDependencies(beads: Array<{
+        id: string;
+        dependencies?: string[];
+    }>, action: DependencyAction): Promise<DependencyResolution>;
+    matchPatterns(query: string, candidates: string[], k: number, threshold: number): Promise<PatternMatch[]>;
+    optimizeConvoy(convoy: {
+        id: string;
+        trackedIssues: string[];
+    }, strategy: ConvoyStrategy, constraints?: unknown): Promise<ConvoyOptimization>;
+}
+
+/**
+ * Gas Town Formula Executor - Hybrid WASM/CLI Implementation
+ *
+ * Provides formula execution with:
+ * - WASM acceleration for parsing and cooking (352x faster)
+ * - CLI bridge fallback for I/O operations
+ * - Progress tracking with event emission
+ * - Step dependency resolution
+ * - Molecule generation from cooked formulas
+ * - Cancellation support
+ *
+ * @module v3/plugins/gastown-bridge/formula/executor
+ */
+
+/**
+ * WASM loader interface for formula operations
+ */
+interface IWasmLoader {
+    /** Check if WASM is initialized */
+    isInitialized(): boolean;
+    /** Parse TOML formula content to AST */
+    parseFormula(content: string): Formula;
+    /** Cook formula with variable substitution */
+    cookFormula(formula: Formula, vars: Record<string, string>): CookedFormula;
+    /** Batch cook multiple formulas */
+    batchCook(formulas: Formula[], varsArray: Record<string, string>[]): CookedFormula[];
+    /** Resolve step dependencies (topological sort) */
+    resolveStepDependencies(steps: Step[]): Step[];
+    /** Detect cycles in step dependencies */
+    detectCycle(steps: Step[]): {
+        hasCycle: boolean;
+        cycleSteps?: string[];
+    };
+}
+/**
+ * Execution options
+ */
+interface ExecuteOptions {
+    /** Target agent for execution */
+    targetAgent?: string;
+    /** Whether to run in dry-run mode (no actual execution) */
+    dryRun?: boolean;
+    /** Timeout per step in milliseconds */
+    stepTimeout?: number;
+    /** Maximum parallel steps */
+    maxParallel?: number;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Custom step handler */
+    stepHandler?: (step: Step, context: StepContext) => Promise<StepResult>;
+}
+/**
+ * Step execution context
+ */
+interface StepContext {
+    /** Execution ID */
+    executionId: string;
+    /** Formula being executed */
+    formula: CookedFormula;
+    /** Current step index */
+    stepIndex: number;
+    /** Total steps */
+    totalSteps: number;
+    /** Variables available to the step */
+    variables: Record<string, string>;
+    /** Results from previous steps */
+    previousResults: Map<string, StepResult>;
+    /** Abort signal */
+    signal?: AbortSignal;
+    /** Execution start time */
+    startTime: Date;
+}
+/**
+ * Step execution result
+ */
+interface StepResult {
+    /** Step ID */
+    stepId: string;
+    /** Whether step succeeded */
+    success: boolean;
+    /** Step output data */
+    output?: unknown;
+    /** Error message if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Step metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Molecule - Generated work unit from cooked formula
+ */
+interface Molecule {
+    /** Unique molecule ID */
+    id: string;
+    /** Parent formula name */
+    formulaName: string;
+    /** Molecule title */
+    title: string;
+    /** Molecule description */
+    description: string;
+    /** Molecule type (from formula type) */
+    type: FormulaType;
+    /** Associated step or leg */
+    sourceId: string;
+    /** Assigned agent */
+    agent?: string;
+    /** Dependencies (other molecule IDs) */
+    dependencies: string[];
+    /** Execution order */
+    order: number;
+    /** Molecule metadata */
+    metadata: Record<string, unknown>;
+    /** Creation timestamp */
+    createdAt: Date;
+}
+/**
+ * Execution progress
+ */
+interface ExecutionProgress {
+    /** Execution ID */
+    executionId: string;
+    /** Formula name */
+    formulaName: string;
+    /** Current status */
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    /** Total steps/legs */
+    totalSteps: number;
+    /** Completed steps */
+    completedSteps: number;
+    /** Failed steps */
+    failedSteps: number;
+    /** Current step being executed */
+    currentStep?: string;
+    /** Start time */
+    startTime: Date;
+    /** End time (if completed) */
+    endTime?: Date;
+    /** Step results */
+    stepResults: StepResult[];
+    /** Error message (if failed) */
+    error?: string;
+    /** Progress percentage (0-100) */
+    percentage: number;
+}
+/**
+ * Executor events
+ */
+interface ExecutorEvents {
+    'execution:start': (executionId: string, formula: CookedFormula) => void;
+    'execution:progress': (progress: ExecutionProgress) => void;
+    'execution:complete': (executionId: string, results: StepResult[]) => void;
+    'execution:error': (executionId: string, error: Error) => void;
+    'execution:cancelled': (executionId: string) => void;
+    'step:start': (executionId: string, step: Step) => void;
+    'step:complete': (executionId: string, result: StepResult) => void;
+    'step:error': (executionId: string, stepId: string, error: Error) => void;
+    'molecule:created': (molecule: Molecule) => void;
+}
+/**
+ * Logger interface
+ */
+interface ExecutorLogger {
+    debug: (msg: string, meta?: Record<string, unknown>) => void;
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Hybrid Formula Executor
+ *
+ * Uses WASM for fast parsing and cooking operations,
+ * falls back to CLI bridge for I/O operations.
+ *
+ * @example
+ * ```typescript
+ * const executor = new FormulaExecutor(gtBridge, wasmLoader);
+ *
+ * // Full execution
+ * const results = await executor.execute('my-formula', { feature: 'auth' });
+ *
+ * // Just cook (WASM-accelerated)
+ * const cooked = await executor.cook('my-formula', { feature: 'auth' });
+ *
+ * // Generate molecules
+ * const molecules = await executor.generateMolecules(cooked);
+ * ```
+ */
+declare class FormulaExecutor extends EventEmitter {
+    private readonly gtBridge;
+    private readonly wasmLoader;
+    private readonly logger;
+    private readonly jsFallback;
+    /** Active executions for progress tracking */
+    private readonly executions;
+    /** Cancellation controllers */
+    private readonly cancellations;
+    /** Debounced progress emitters per execution */
+    private readonly progressEmitters;
+    /** Default max parallel workers */
+    private readonly defaultMaxParallel;
+    constructor(gtBridge: GtBridge, wasmLoader?: IWasmLoader, logger?: ExecutorLogger);
+    /**
+     * Execute a formula with full lifecycle
+     *
+     * @param formulaName - Name of the formula to execute
+     * @param vars - Variables for substitution
+     * @param options - Execution options
+     * @returns Array of step results
+     */
+    execute(formulaName: string, vars: Record<string, string>, options?: ExecuteOptions): Promise<StepResult[]>;
+    /**
+     * Cook a formula with variable substitution (WASM-accelerated)
+     *
+     * @param formulaName - Name of the formula or TOML content
+     * @param vars - Variables for substitution
+     * @returns Cooked formula with substituted variables
+     */
+    cook(formulaName: string, vars: Record<string, string>): Promise<CookedFormula>;
+    /**
+     * Generate molecules from a cooked formula
+     *
+     * Molecules are executable work units derived from formula steps/legs.
+     * Uses object pooling for reduced allocations.
+     *
+     * @param cookedFormula - The cooked formula to generate molecules from
+     * @returns Array of molecules
+     */
+    generateMolecules(cookedFormula: CookedFormula): Promise<Molecule[]>;
+    /**
+     * Run a single step
+     *
+     * @param step - Step to execute
+     * @param context - Execution context
+     * @param options - Execution options
+     * @returns Step result
+     */
+    runStep(step: Step, context: StepContext, options?: ExecuteOptions): Promise<StepResult>;
+    /**
+     * Get execution progress
+     *
+     * @param executionId - Execution ID to get progress for
+     * @returns Execution progress or undefined
+     */
+    getProgress(executionId: string): ExecutionProgress | undefined;
+    /**
+     * Cancel an execution
+     *
+     * @param executionId - Execution ID to cancel
+     * @returns Whether cancellation was initiated
+     */
+    cancel(executionId: string): boolean;
+    /**
+     * List all active executions
+     */
+    getActiveExecutions(): ExecutionProgress[];
+    /**
+     * Check if WASM is available for acceleration
+     */
+    isWasmAvailable(): boolean;
+    /**
+     * Get cache statistics for performance monitoring
+     */
+    getCacheStats(): {
+        stepResultCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+        cookCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+    };
+    /**
+     * Clear all executor caches
+     */
+    clearCaches(): void;
+    /**
+     * Parse formula content using WASM or JS fallback
+     */
+    private parseFormula;
+    /**
+     * Fetch formula from CLI
+     */
+    private fetchFormula;
+    /**
+     * Validate required variables are provided
+     */
+    private validateVariables;
+    /**
+     * Resolve step dependencies using WASM or JS fallback
+     */
+    private resolveStepDependencies;
+    /**
+     * Get ordered execution units (steps or legs) from formula
+     */
+    private getOrderedExecutionUnits;
+    /**
+     * Execute step via CLI bridge
+     */
+    private executeStepViaCli;
+    /**
+     * Merge multiple abort signals
+     */
+    private mergeSignals;
+}
+/**
+ * Create a new FormulaExecutor instance
+ */
+declare function createFormulaExecutor(gtBridge: GtBridge, wasmLoader?: IWasmLoader, logger?: ExecutorLogger): FormulaExecutor;
+
+/**
+ * Convoy Tracker
+ *
+ * Manages convoy lifecycle including creation, modification, progress
+ * tracking, and completion. Convoys are work-order groups that track
+ * related beads (issues) through their lifecycle.
+ *
+ * Features:
+ * - Create and manage convoy groups
+ * - Add/remove beads to convoys
+ * - Track progress and status changes
+ * - Event emission for status transitions
+ * - Integration with bd-bridge for bead operations
+ *
+ * @module gastown-bridge/convoy/tracker
+ */
+
+/**
+ * Convoy event types
+ */
+type ConvoyEventType = 'convoy:created' | 'convoy:started' | 'convoy:progressed' | 'convoy:completed' | 'convoy:cancelled' | 'convoy:paused' | 'convoy:resumed' | 'convoy:issue:added' | 'convoy:issue:removed' | 'convoy:issue:updated';
+/**
+ * Convoy event payload
+ */
+interface ConvoyEvent {
+    /** Event type */
+    type: ConvoyEventType;
+    /** Convoy ID */
+    convoyId: string;
+    /** Convoy name */
+    convoyName: string;
+    /** Event timestamp */
+    timestamp: Date;
+    /** Previous status (for status change events) */
+    previousStatus?: ConvoyStatus;
+    /** Current status */
+    status: ConvoyStatus;
+    /** Progress at time of event */
+    progress: ConvoyProgress;
+    /** Issue IDs affected (for issue events) */
+    issues?: string[];
+    /** Cancellation reason (for cancelled events) */
+    reason?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Convoy tracker configuration
+ */
+interface ConvoyTrackerConfig {
+    /** BD bridge instance for bead operations */
+    bdBridge: BdBridge;
+    /** Auto-update progress on issue changes */
+    autoUpdateProgress?: boolean;
+    /** Progress update interval in milliseconds */
+    progressUpdateInterval?: number;
+    /** Enable persistent storage */
+    persistConvoys?: boolean;
+    /** Storage path for convoy data */
+    storagePath?: string;
+}
+/**
+ * Logger interface
+ */
+interface ConvoyLogger {
+    debug: (msg: string, meta?: Record<string, unknown>) => void;
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Convoy Tracker
+ *
+ * Manages convoy lifecycle and tracks progress of grouped work.
+ *
+ * @example
+ * ```typescript
+ * const tracker = new ConvoyTracker({
+ *   bdBridge: await createBdBridge().initialize(),
+ * });
+ *
+ * // Create a convoy
+ * const convoy = await tracker.create(
+ *   'Sprint 1',
+ *   ['gt-abc12', 'gt-def34', 'gt-ghi56'],
+ *   'First sprint tasks'
+ * );
+ *
+ * // Monitor progress
+ * tracker.on('convoy:progressed', (event) => {
+ *   console.log(`Progress: ${event.progress.closed}/${event.progress.total}`);
+ * });
+ *
+ * // Check status
+ * const status = await tracker.getStatus(convoy.id);
+ * ```
+ */
+declare class ConvoyTracker extends EventEmitter {
+    private bdBridge;
+    private convoys;
+    private logger;
+    private config;
+    private progressTimers;
+    constructor(config: ConvoyTrackerConfig, logger?: ConvoyLogger);
+    /**
+     * Create a new convoy
+     *
+     * @param name - Convoy name
+     * @param issues - Issue IDs to include
+     * @param description - Optional description
+     * @returns Created convoy
+     */
+    create(name: string, issues: string[], description?: string): Promise<Convoy>;
+    /**
+     * Add issues to an existing convoy
+     *
+     * @param convoyId - Convoy ID
+     * @param issues - Issue IDs to add
+     * @returns Updated convoy
+     */
+    addIssues(convoyId: string, issues: string[]): Promise<Convoy>;
+    /**
+     * Remove issues from a convoy
+     *
+     * @param convoyId - Convoy ID
+     * @param issues - Issue IDs to remove
+     * @returns Updated convoy
+     */
+    removeIssues(convoyId: string, issues: string[]): Promise<Convoy>;
+    /**
+     * Get convoy status
+     *
+     * @param convoyId - Convoy ID
+     * @returns Convoy with updated progress
+     */
+    getStatus(convoyId: string): Promise<Convoy>;
+    /**
+     * Mark convoy as complete
+     *
+     * @param convoyId - Convoy ID
+     * @returns Completed convoy
+     */
+    complete(convoyId: string): Promise<Convoy>;
+    /**
+     * Cancel a convoy
+     *
+     * @param convoyId - Convoy ID
+     * @param reason - Cancellation reason
+     * @returns Cancelled convoy
+     */
+    cancel(convoyId: string, reason?: string): Promise<Convoy>;
+    /**
+     * Pause a convoy
+     *
+     * @param convoyId - Convoy ID
+     * @returns Paused convoy
+     */
+    pause(convoyId: string): Promise<Convoy>;
+    /**
+     * Resume a paused convoy
+     *
+     * @param convoyId - Convoy ID
+     * @returns Resumed convoy
+     */
+    resume(convoyId: string): Promise<Convoy>;
+    /**
+     * List all convoys
+     *
+     * @param status - Optional status filter
+     * @returns Array of convoys
+     */
+    listConvoys(status?: ConvoyStatus): Convoy[];
+    /**
+     * Get convoy by ID
+     *
+     * @param convoyId - Convoy ID
+     * @returns Convoy or undefined
+     */
+    getConvoy(convoyId: string): Convoy | undefined;
+    /**
+     * Delete a convoy
+     *
+     * @param convoyId - Convoy ID
+     * @returns True if deleted
+     */
+    deleteConvoy(convoyId: string): boolean;
+    /**
+     * Calculate progress for a set of issues
+     */
+    private calculateProgress;
+    /**
+     * Verify issues exist
+     */
+    private verifyIssues;
+    /**
+     * Fetch beads by IDs
+     */
+    private fetchBeads;
+    /**
+     * Map CLI bead type to Gas Town status
+     */
+    private mapBeadStatus;
+    /**
+     * Start progress tracking timer
+     */
+    private startProgressTracking;
+    /**
+     * Stop progress tracking timer
+     */
+    private stopProgressTracking;
+    /**
+     * Emit convoy event
+     */
+    private emitConvoyEvent;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+/**
+ * Create a new convoy tracker instance
+ */
+declare function createConvoyTracker(config: ConvoyTrackerConfig, logger?: ConvoyLogger): ConvoyTracker;
+
+/**
+ * Object Pooling for Gas Town Bridge Plugin
+ *
+ * Provides high-performance object pooling to minimize GC pressure
+ * and reduce memory allocations for frequently created objects.
+ *
+ * Target: 75% memory reduction, <10MB heap for 10k beads
+ *
+ * Pooled object types:
+ * - Bead: Git-backed issue tracking objects
+ * - Formula: TOML-defined workflow definitions
+ * - Step: Individual workflow steps
+ * - Convoy: Work-order tracking containers
+ * - Molecule: Generated work units
+ *
+ * @module gastown-bridge/memory/pool
+ */
+
+/**
+ * Poolable object interface - objects that can be reset and reused
+ */
+interface Poolable {
+    /** Reset object to initial state for reuse */
+    reset?(): void;
+}
+/**
+ * Pool statistics for monitoring
+ */
+interface PoolStats {
+    /** Total objects created (including pooled) */
+    created: number;
+    /** Objects currently in pool (available) */
+    available: number;
+    /** Objects currently in use */
+    inUse: number;
+    /** Number of times pool was empty on acquire */
+    misses: number;
+    /** Number of successful pool acquisitions */
+    hits: number;
+    /** Peak pool size reached */
+    peakSize: number;
+    /** Memory saved (estimated bytes) */
+    memorySaved: number;
+}
+/**
+ * Pool configuration
+ */
+interface PoolConfig {
+    /** Initial pool size */
+    initialSize?: number;
+    /** Maximum pool size (0 = unlimited) */
+    maxSize?: number;
+    /** Estimated object size in bytes (for memory tracking) */
+    objectSizeBytes?: number;
+    /** Whether to pre-warm the pool */
+    preWarm?: boolean;
+}
+/**
+ * High-performance generic object pool
+ *
+ * Uses a simple array-based free list for O(1) acquire/release.
+ * Supports both factory functions and prototype-based object creation.
+ *
+ * @example
+ * ```typescript
+ * const beadPool = new ObjectPool<PooledBead>({
+ *   factory: () => new PooledBead(),
+ *   reset: (bead) => bead.reset(),
+ *   initialSize: 100,
+ *   maxSize: 10000,
+ * });
+ *
+ * const bead = beadPool.acquire();
+ * // ... use bead ...
+ * beadPool.release(bead);
+ * ```
+ */
+declare class ObjectPool<T extends object> {
+    private pool;
+    private factory;
+    private resetFn?;
+    private config;
+    private stats;
+    constructor(factory: () => T, options?: PoolConfig & {
+        reset?: (obj: T) => void;
+    });
+    /**
+     * Acquire an object from the pool
+     *
+     * Returns a pooled object if available, otherwise creates a new one.
+     * O(1) operation using array pop.
+     */
+    acquire(): T;
+    /**
+     * Release an object back to the pool
+     *
+     * Resets the object and returns it to the pool for reuse.
+     * O(1) operation using array push.
+     *
+     * @param obj - Object to release
+     */
+    release(obj: T): void;
+    /**
+     * Release multiple objects at once (batch operation)
+     */
+    releaseAll(objects: T[]): void;
+    /**
+     * Pre-warm the pool with objects
+     */
+    preWarm(count: number): void;
+    /**
+     * Clear the pool and release all objects
+     */
+    clear(): void;
+    /**
+     * Get pool statistics
+     */
+    getStats(): Readonly<PoolStats>;
+    /**
+     * Get current pool size
+     */
+    get size(): number;
+    /**
+     * Get hit rate (percentage of successful pool acquisitions)
+     */
+    get hitRate(): number;
+}
+/**
+ * Pooled Bead object with reset capability
+ */
+declare class PooledBead implements Bead, Poolable {
+    id: string;
+    title: string;
+    description: string;
+    status: BeadStatus;
+    priority: number;
+    labels: string[];
+    createdAt: Date;
+    updatedAt: Date;
+    parentId?: string;
+    assignee?: string;
+    rig?: string;
+    blockedBy?: string[];
+    blocks?: string[];
+    reset(): void;
+    /**
+     * Initialize from a Bead-like object
+     */
+    initFrom(source: Partial<Bead>): this;
+}
+/**
+ * Pooled Step object with reset capability
+ */
+declare class PooledStep implements Step, Poolable {
+    id: string;
+    title: string;
+    description: string;
+    needs?: string[];
+    duration?: number;
+    requires?: string[];
+    metadata?: Record<string, unknown>;
+    reset(): void;
+    initFrom(source: Partial<Step>): this;
+}
+/**
+ * Pooled Formula object with reset capability
+ */
+declare class PooledFormula implements Formula, Poolable {
+    name: string;
+    description: string;
+    type: FormulaType;
+    version: number;
+    steps?: Step[];
+    legs?: Formula['legs'];
+    vars?: Formula['vars'];
+    metadata?: Formula['metadata'];
+    reset(): void;
+    initFrom(source: Partial<Formula>): this;
+}
+/**
+ * Pooled Convoy object with reset capability
+ */
+declare class PooledConvoy implements Convoy, Poolable {
+    id: string;
+    name: string;
+    trackedIssues: string[];
+    status: ConvoyStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    progress: {
+        total: number;
+        closed: number;
+        inProgress: number;
+        blocked: number;
+    };
+    formula?: string;
+    description?: string;
+    reset(): void;
+    initFrom(source: Partial<Convoy>): this;
+}
+/**
+ * Pooled Molecule object with reset capability
+ */
+declare class PooledMolecule implements Molecule, Poolable {
+    id: string;
+    formulaName: string;
+    title: string;
+    description: string;
+    type: FormulaType;
+    sourceId: string;
+    agent?: string;
+    dependencies: string[];
+    order: number;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    reset(): void;
+    initFrom(source: Partial<Molecule>): this;
+}
+/**
+ * Global Bead pool - optimized for 10k beads target
+ * Estimated size per bead: ~512 bytes
+ */
+declare const beadPool: ObjectPool<PooledBead>;
+/**
+ * Global Formula pool
+ * Estimated size per formula: ~1KB
+ */
+declare const formulaPool: ObjectPool<PooledFormula>;
+/**
+ * Global Step pool
+ * Estimated size per step: ~256 bytes
+ */
+declare const stepPool: ObjectPool<PooledStep>;
+/**
+ * Global Convoy pool
+ * Estimated size per convoy: ~768 bytes
+ */
+declare const convoyPool: ObjectPool<PooledConvoy>;
+/**
+ * Global Molecule pool
+ * Estimated size per molecule: ~384 bytes
+ */
+declare const moleculePool: ObjectPool<PooledMolecule>;
+/**
+ * All managed pools
+ */
+declare const allPools: {
+    readonly bead: ObjectPool<PooledBead>;
+    readonly formula: ObjectPool<PooledFormula>;
+    readonly step: ObjectPool<PooledStep>;
+    readonly convoy: ObjectPool<PooledConvoy>;
+    readonly molecule: ObjectPool<PooledMolecule>;
+};
+type PoolType = keyof typeof allPools;
+/**
+ * Get statistics for all pools
+ */
+declare function getAllPoolStats(): Record<PoolType, PoolStats>;
+/**
+ * Get total memory saved across all pools
+ */
+declare function getTotalMemorySaved(): number;
+/**
+ * Clear all pools
+ */
+declare function clearAllPools(): void;
+/**
+ * Pre-warm all pools with default sizes
+ */
+declare function preWarmAllPools(): void;
+/**
+ * Get a summary of pool efficiency
+ */
+declare function getPoolEfficiencySummary(): {
+    totalHitRate: number;
+    totalMemorySavedKB: number;
+    totalObjectsInUse: number;
+    totalObjectsAvailable: number;
+};
+
+/**
+ * Arena Allocator for Gas Town Bridge Plugin
+ *
+ * Provides bulk memory allocation with single-operation deallocation.
+ * Ideal for batch operations where many objects are created and then
+ * discarded together (e.g., convoy graph operations, formula parsing).
+ *
+ * Benefits:
+ * - O(1) reset/clear operation
+ * - Reduced GC pressure for batch operations
+ * - Better memory locality
+ * - Predictable memory usage
+ *
+ * @module gastown-bridge/memory/arena
+ */
+
+/**
+ * Arena statistics
+ */
+interface ArenaStats {
+    /** Total allocations since creation */
+    totalAllocations: number;
+    /** Current allocations (not yet reset) */
+    currentAllocations: number;
+    /** Number of reset operations */
+    resetCount: number;
+    /** Peak allocations before reset */
+    peakAllocations: number;
+    /** Estimated memory in use (bytes) */
+    memoryUsed: number;
+    /** Total memory saved via bulk reset (bytes) */
+    memorySaved: number;
+}
+/**
+ * Arena configuration
+ */
+interface ArenaConfig {
+    /** Name for debugging */
+    name?: string;
+    /** Initial capacity hint */
+    initialCapacity?: number;
+    /** Maximum allocations before forced reset */
+    maxAllocations?: number;
+    /** Enable automatic pool return on reset */
+    returnToPool?: boolean;
+}
+/**
+ * Arena Allocator
+ *
+ * Manages bulk allocations that are reset together. Uses underlying
+ * object pools when available for maximum efficiency.
+ *
+ * @example
+ * ```typescript
+ * const arena = new Arena('convoy-analysis');
+ *
+ * // Allocate objects for batch operation
+ * const beads = arena.allocateMany('bead', 100);
+ * const steps = arena.allocateMany('step', 50);
+ *
+ * // Process...
+ *
+ * // Single O(1) reset clears everything
+ * arena.reset();
+ * ```
+ */
+declare class Arena {
+    private name;
+    private config;
+    private allocations;
+    private stats;
+    private beadPool;
+    private stepPool;
+    private formulaPool;
+    private convoyPool;
+    private moleculePool;
+    constructor(name?: string, config?: ArenaConfig);
+    /**
+     * Allocate an object from the arena
+     *
+     * Uses pooled objects when available for the given type.
+     */
+    allocate<T>(factory: () => T, sizeBytes?: number): T;
+    /**
+     * Allocate a typed object from the arena pools
+     */
+    allocateTyped<K extends AllocatableType>(type: K): TypeMap[K];
+    /**
+     * Allocate multiple typed objects
+     */
+    allocateMany<K extends AllocatableType>(type: K, count: number): TypeMap[K][];
+    /**
+     * Reset the arena, returning all objects to their pools
+     *
+     * This is an O(n) operation where n is the number of allocations,
+     * but it's a single operation instead of n individual deallocations.
+     */
+    reset(): void;
+    /**
+     * Get arena statistics
+     */
+    getStats(): Readonly<ArenaStats>;
+    /**
+     * Get current allocation count
+     */
+    get allocationCount(): number;
+    /**
+     * Get arena name
+     */
+    get arenaName(): string;
+    /**
+     * Dispose the arena and all its resources
+     */
+    dispose(): void;
+    private trackAllocation;
+    private checkMaxAllocations;
+    private returnToPool;
+}
+/**
+ * Allocatable type names
+ */
+type AllocatableType = 'bead' | 'step' | 'formula' | 'convoy' | 'molecule';
+/**
+ * Type map for allocatable types
+ */
+interface TypeMap {
+    bead: PooledBead;
+    step: PooledStep;
+    formula: PooledFormula;
+    convoy: PooledConvoy;
+    molecule: PooledMolecule;
+}
+/**
+ * Scoped arena that auto-resets when disposed
+ *
+ * Useful for RAII-style memory management with try/finally patterns.
+ *
+ * @example
+ * ```typescript
+ * using arena = scopedArena('batch-operation');
+ * const beads = arena.allocateMany('bead', 100);
+ * // ... process beads ...
+ * // Arena automatically resets when scope exits
+ * ```
+ */
+declare function scopedArena(name: string, config?: ArenaConfig): Arena & Disposable;
+/**
+ * Execute a function with a scoped arena
+ *
+ * The arena is automatically reset after the function completes.
+ */
+declare function withArena<T>(name: string, fn: (arena: Arena) => T | Promise<T>, config?: ArenaConfig): Promise<T>;
+/**
+ * Synchronous version of withArena
+ */
+declare function withArenaSync<T>(name: string, fn: (arena: Arena) => T, config?: ArenaConfig): T;
+/**
+ * Manages multiple arenas for different operation types
+ */
+declare class ArenaManager {
+    private arenas;
+    private stats;
+    /**
+     * Get or create an arena by name
+     */
+    getArena(name: string, config?: ArenaConfig): Arena;
+    /**
+     * Reset a specific arena
+     */
+    resetArena(name: string): void;
+    /**
+     * Reset all arenas
+     */
+    resetAll(): void;
+    /**
+     * Dispose an arena
+     */
+    disposeArena(name: string): void;
+    /**
+     * Dispose all arenas
+     */
+    disposeAll(): void;
+    /**
+     * Get manager statistics
+     */
+    getStats(): typeof this.stats & {
+        arenaStats: Record<string, ArenaStats>;
+    };
+}
+/**
+ * Global arena manager instance
+ */
+declare const arenaManager: ArenaManager;
+
+/**
+ * Memory Monitoring for Gas Town Bridge Plugin
+ *
+ * Provides comprehensive memory monitoring, limits, and pressure callbacks.
+ * Integrates with object pools and arena allocators to track memory usage.
+ *
+ * Target: <10MB heap for 10k beads
+ *
+ * Features:
+ * - Real-time memory usage tracking
+ * - Configurable memory limits
+ * - Memory pressure callbacks
+ * - Automatic cleanup triggers
+ * - Integration with V8 GC hooks (when available)
+ *
+ * @module gastown-bridge/memory/monitor
+ */
+
+/**
+ * Memory statistics snapshot
+ */
+interface MemoryStats {
+    /** Heap memory used (bytes) */
+    heapUsed: number;
+    /** Heap memory total (bytes) */
+    heapTotal: number;
+    /** External memory (bytes) */
+    external: number;
+    /** Array buffers memory (bytes) */
+    arrayBuffers: number;
+    /** RSS (Resident Set Size) in bytes */
+    rss: number;
+    /** Pool memory stats */
+    pools: {
+        totalMemorySaved: number;
+        hitRate: number;
+        objectsInUse: number;
+        objectsAvailable: number;
+    };
+    /** Arena memory stats */
+    arenas: {
+        activeArenas: number;
+        totalMemoryUsed: number;
+        totalMemorySaved: number;
+    };
+    /** Timestamp of snapshot */
+    timestamp: Date;
+    /** Whether under memory pressure */
+    underPressure: boolean;
+}
+/**
+ * Memory pressure levels
+ */
+type MemoryPressureLevel = 'none' | 'low' | 'medium' | 'high' | 'critical';
+/**
+ * Memory pressure callback
+ */
+type MemoryPressureCallback = (level: MemoryPressureLevel, stats: MemoryStats) => void;
+/**
+ * Memory monitor configuration
+ */
+interface MemoryMonitorConfig {
+    /** Memory limit in bytes (0 = no limit) */
+    memoryLimit?: number;
+    /** Low pressure threshold (0-1 of limit) */
+    lowPressureThreshold?: number;
+    /** Medium pressure threshold (0-1 of limit) */
+    mediumPressureThreshold?: number;
+    /** High pressure threshold (0-1 of limit) */
+    highPressureThreshold?: number;
+    /** Critical pressure threshold (0-1 of limit) */
+    criticalPressureThreshold?: number;
+    /** Polling interval in ms (0 = manual only) */
+    pollInterval?: number;
+    /** Enable automatic cleanup on pressure */
+    autoCleanup?: boolean;
+    /** Enable GC hints when available */
+    gcHints?: boolean;
+}
+/**
+ * Memory monitor events
+ */
+interface MemoryMonitorEvents {
+    'pressure:none': (stats: MemoryStats) => void;
+    'pressure:low': (stats: MemoryStats) => void;
+    'pressure:medium': (stats: MemoryStats) => void;
+    'pressure:high': (stats: MemoryStats) => void;
+    'pressure:critical': (stats: MemoryStats) => void;
+    'limit:exceeded': (stats: MemoryStats) => void;
+    'cleanup:triggered': (beforeStats: MemoryStats, afterStats: MemoryStats) => void;
+    'snapshot': (stats: MemoryStats) => void;
+}
+/**
+ * Memory Monitor
+ *
+ * Tracks memory usage and triggers pressure callbacks when thresholds
+ * are exceeded. Integrates with object pools and arenas.
+ *
+ * @example
+ * ```typescript
+ * const monitor = new MemoryMonitor({
+ *   memoryLimit: 10 * 1024 * 1024, // 10MB
+ *   pollInterval: 1000,
+ *   autoCleanup: true,
+ * });
+ *
+ * monitor.onMemoryPressure((level, stats) => {
+ *   console.log(`Memory pressure: ${level}`, stats);
+ * });
+ *
+ * monitor.start();
+ * ```
+ */
+declare class MemoryMonitor extends EventEmitter {
+    private config;
+    private pollTimer?;
+    private pressureCallbacks;
+    private lastPressureLevel;
+    private running;
+    private statsHistory;
+    private maxHistorySize;
+    constructor(config?: MemoryMonitorConfig);
+    /**
+     * Get current memory usage statistics
+     */
+    getMemoryUsage(): MemoryStats;
+    /**
+     * Set memory limit
+     */
+    setMemoryLimit(bytes: number): void;
+    /**
+     * Get current memory limit
+     */
+    getMemoryLimit(): number;
+    /**
+     * Register a memory pressure callback
+     */
+    onMemoryPressure(callback: MemoryPressureCallback): () => void;
+    /**
+     * Check current pressure level
+     */
+    checkPressure(): MemoryPressureLevel;
+    /**
+     * Start monitoring
+     */
+    start(): void;
+    /**
+     * Stop monitoring
+     */
+    stop(): void;
+    /**
+     * Manual poll (also called automatically if pollInterval > 0)
+     */
+    poll(): void;
+    /**
+     * Trigger memory cleanup
+     */
+    triggerCleanup(): void;
+    /**
+     * Get memory trend (bytes/second)
+     */
+    getMemoryTrend(): number;
+    /**
+     * Estimate time until limit reached (ms)
+     */
+    estimateTimeToLimit(): number | null;
+    /**
+     * Get pool-specific statistics
+     */
+    getPoolStats(): Record<string, PoolStats>;
+    /**
+     * Get historical stats
+     */
+    getHistory(): MemoryStats[];
+    /**
+     * Clear historical stats
+     */
+    clearHistory(): void;
+    /**
+     * Check if running
+     */
+    isRunning(): boolean;
+    /**
+     * Get configuration
+     */
+    getConfig(): Readonly<Required<MemoryMonitorConfig>>;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<MemoryMonitorConfig>): void;
+}
+/**
+ * Get current memory usage (simple API)
+ */
+declare function getMemoryUsage(): MemoryStats;
+/**
+ * Set a memory limit and callback (simple API)
+ */
+declare function setMemoryLimit(bytes: number, onPressure?: MemoryPressureCallback): MemoryMonitor;
+declare function onMemoryPressure(callback: MemoryPressureCallback): () => void;
+/**
+ * Get the default monitor instance
+ */
+declare function getDefaultMonitor(): MemoryMonitor | null;
+/**
+ * Stop and dispose the default monitor
+ */
+declare function disposeDefaultMonitor(): void;
+/**
+ * Memory budget for component-level tracking
+ */
+interface MemoryBudget {
+    name: string;
+    allocated: number;
+    used: number;
+    limit: number;
+}
+/**
+ * Memory budget manager
+ */
+declare class MemoryBudgetManager {
+    private budgets;
+    private totalLimit;
+    constructor(totalLimit?: number);
+    /**
+     * Allocate a budget for a component
+     */
+    allocateBudget(name: string, limit: number): boolean;
+    /**
+     * Update usage for a budget
+     */
+    updateUsage(name: string, used: number): void;
+    /**
+     * Check if a budget is exceeded
+     */
+    isExceeded(name: string): boolean;
+    /**
+     * Get budget for a component
+     */
+    getBudget(name: string): MemoryBudget | undefined;
+    /**
+     * Get all budgets
+     */
+    getAllBudgets(): MemoryBudget[];
+    /**
+     * Get total allocated budget
+     */
+    getTotalAllocated(): number;
+    /**
+     * Get total used
+     */
+    getTotalUsed(): number;
+    /**
+     * Free a budget
+     */
+    freeBudget(name: string): void;
+    /**
+     * Get total limit
+     */
+    getTotalLimit(): number;
+    /**
+     * Set total limit
+     */
+    setTotalLimit(limit: number): void;
+}
+/**
+ * Global memory budget manager for 10MB target
+ */
+declare const memoryBudget: MemoryBudgetManager;
+
+/**
+ * Lazy Loading Utilities for Gas Town Bridge Plugin
+ *
+ * Provides lazy initialization patterns to defer resource loading
+ * until first use, reducing initial memory footprint and startup time.
+ *
+ * Features:
+ * - Lazy WASM module loading
+ * - Deferred convoy observer initialization
+ * - Lazy bridge initialization
+ * - Resource cleanup on idle
+ *
+ * @module gastown-bridge/memory/lazy
+ */
+/**
+ * Lazy value state
+ */
+type LazyState = 'uninitialized' | 'initializing' | 'initialized' | 'error' | 'disposed';
+/**
+ * Lazy initialization options
+ */
+interface LazyOptions<T> {
+    /** Factory function to create the value */
+    factory: () => T | Promise<T>;
+    /** Optional cleanup function */
+    cleanup?: (value: T) => void | Promise<void>;
+    /** Auto-dispose after idle time (ms, 0 = never) */
+    idleTimeout?: number;
+    /** Error handler */
+    onError?: (error: Error) => void;
+    /** Name for debugging */
+    name?: string;
+}
+/**
+ * Lazy loader statistics
+ */
+interface LazyStats {
+    name: string;
+    state: LazyState;
+    initCount: number;
+    disposeCount: number;
+    errorCount: number;
+    lastInitTime?: Date;
+    lastAccessTime?: Date;
+    initDurationMs?: number;
+}
+/**
+ * Lazy value wrapper with automatic initialization
+ *
+ * @example
+ * ```typescript
+ * const lazyWasm = new Lazy({
+ *   name: 'wasm-module',
+ *   factory: async () => await loadWasmModule(),
+ *   cleanup: (wasm) => wasm.dispose(),
+ *   idleTimeout: 60000, // Auto-dispose after 1 minute of inactivity
+ * });
+ *
+ * // First access triggers initialization
+ * const wasm = await lazyWasm.get();
+ *
+ * // Check if initialized without triggering
+ * if (lazyWasm.isInitialized()) { ... }
+ *
+ * // Manual disposal
+ * await lazyWasm.dispose();
+ * ```
+ */
+declare class Lazy<T> {
+    private value?;
+    private state;
+    private initPromise?;
+    private idleTimer?;
+    private options;
+    private stats;
+    constructor(options: LazyOptions<T>);
+    /**
+     * Get the lazy value, initializing if necessary
+     */
+    get(): Promise<T>;
+    /**
+     * Get synchronously (throws if not initialized)
+     */
+    getSync(): T;
+    /**
+     * Check if initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current state
+     */
+    getState(): LazyState;
+    /**
+     * Initialize without returning value
+     */
+    initialize(): Promise<T>;
+    /**
+     * Dispose the lazy value
+     */
+    dispose(): Promise<void>;
+    /**
+     * Get statistics
+     */
+    getStats(): Readonly<LazyStats>;
+    private resetIdleTimer;
+    private clearIdleTimer;
+}
+/**
+ * Get or create a lazy singleton
+ */
+declare function getLazySingleton<T>(key: string, options: LazyOptions<T>): Lazy<T>;
+/**
+ * Dispose a lazy singleton
+ */
+declare function disposeLazySingleton(key: string): Promise<void>;
+/**
+ * Dispose all lazy singletons
+ */
+declare function disposeAllLazySingletons(): Promise<void>;
+/**
+ * Lazy module loader for dynamic imports
+ *
+ * @example
+ * ```typescript
+ * const wasmLoader = new LazyModule(() => import('./wasm-loader.js'));
+ * const { parseFormula } = await wasmLoader.get();
+ * ```
+ */
+declare class LazyModule<T> {
+    private lazy;
+    constructor(importer: () => Promise<T>, options?: Omit<LazyOptions<T>, 'factory'>);
+    /**
+     * Get the module
+     */
+    get(): Promise<T>;
+    /**
+     * Check if loaded
+     */
+    isLoaded(): boolean;
+    /**
+     * Dispose module
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Lazy bridge wrapper for Gas Town bridges
+ *
+ * Defers bridge initialization until first use.
+ */
+declare class LazyBridge<T extends {
+    initialize?: () => Promise<void>;
+}> {
+    private lazy;
+    constructor(factory: () => T | Promise<T>, options?: Omit<LazyOptions<T>, 'factory'>);
+    /**
+     * Get the bridge
+     */
+    get(): Promise<T>;
+    /**
+     * Check if initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Dispose bridge
+     */
+    dispose(): Promise<void>;
+    /**
+     * Get stats
+     */
+    getStats(): LazyStats;
+}
+/**
+ * Lazy WASM module loader with caching
+ */
+declare class LazyWasm<T> {
+    private lazy;
+    private cached;
+    constructor(loader: () => Promise<T>, options?: {
+        name?: string;
+        idleTimeout?: number;
+        onError?: (error: Error) => void;
+    });
+    /**
+     * Get the WASM module
+     */
+    get(): Promise<T>;
+    /**
+     * Check if loaded
+     */
+    isLoaded(): boolean;
+    /**
+     * Clear cache (module will be reloaded on next access)
+     */
+    clearCache(): void;
+    /**
+     * Get stats
+     */
+    getStats(): LazyStats;
+}
+/**
+ * Lazy observer pattern for convoy watching
+ *
+ * Defers observer creation until first watch request.
+ */
+declare class LazyObserver<T> {
+    private lazy;
+    private watchCount;
+    constructor(factory: () => T | Promise<T>, options?: Omit<LazyOptions<T>, 'factory'>);
+    /**
+     * Start watching (initializes observer if needed)
+     */
+    watch(): Promise<T>;
+    /**
+     * Stop watching (disposes observer if no more watchers)
+     */
+    unwatch(): Promise<void>;
+    /**
+     * Get current watch count
+     */
+    getWatchCount(): number;
+    /**
+     * Check if active
+     */
+    isActive(): boolean;
+    /**
+     * Force dispose
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Create a lazy property getter
+ */
+declare function createLazyProperty<T>(factory: () => T | Promise<T>, options?: Omit<LazyOptions<T>, 'factory'>): {
+    get: () => Promise<T>;
+    isInitialized: () => boolean;
+};
+
+/**
+ * Memory Management Module for Gas Town Bridge Plugin
+ *
+ * Provides comprehensive memory optimization through:
+ * - Object pooling for frequently allocated objects (Bead, Formula, Step, Convoy, Molecule)
+ * - Arena allocators for batch operations with O(1) reset
+ * - Memory monitoring with pressure callbacks
+ * - Lazy loading for deferred resource initialization
+ *
+ * Target: 75% memory reduction, <10MB heap for 10k beads
+ *
+ * @module gastown-bridge/memory
+ */
+
+/**
+ * Memory system configuration
+ */
+interface MemorySystemConfig {
+    /** Memory limit in bytes (default: 10MB) */
+    memoryLimit?: number;
+    /** Enable auto-cleanup on pressure */
+    autoCleanup?: boolean;
+    /** Pre-warm pools on init */
+    preWarmPools?: boolean;
+    /** Polling interval for monitor (ms) */
+    pollInterval?: number;
+}
+/**
+ * Memory system state
+ */
+interface MemorySystemState {
+    initialized: boolean;
+    monitor: MemoryMonitor | null;
+    config: MemorySystemConfig;
+}
+/**
+ * Initialize the memory management system
+ *
+ * @example
+ * ```typescript
+ * import { initializeMemorySystem, getSystemMemoryStats } from './memory/index.js';
+ *
+ * await initializeMemorySystem({
+ *   memoryLimit: 10 * 1024 * 1024, // 10MB
+ *   autoCleanup: true,
+ *   preWarmPools: true,
+ * });
+ *
+ * // Monitor memory usage
+ * const stats = getSystemMemoryStats();
+ * console.log('Heap used:', stats.heapUsed);
+ * ```
+ */
+declare function initializeMemorySystem(config?: MemorySystemConfig): void;
+/**
+ * Get system memory statistics
+ */
+declare function getSystemMemoryStats(): MemoryStats | null;
+/**
+ * Get comprehensive memory report
+ */
+declare function getMemoryReport(): {
+    system: MemoryStats | null;
+    pools: ReturnType<typeof getAllPoolStats>;
+    poolEfficiency: ReturnType<typeof getPoolEfficiencySummary>;
+    arenas: ReturnType<typeof arenaManager.getStats>;
+    config: MemorySystemConfig;
+};
+/**
+ * Trigger manual memory cleanup
+ */
+declare function triggerMemoryCleanup(): void;
+/**
+ * Shutdown the memory system
+ */
+declare function shutdownMemorySystem(): Promise<void>;
+/**
+ * Check if memory system is initialized
+ */
+declare function isMemorySystemInitialized(): boolean;
+/**
+ * Get memory system monitor
+ */
+declare function getMemoryMonitor(): MemoryMonitor | null;
+
+/**
+ * Acquire a pooled bead
+ */
+declare function acquireBead(): PooledBead;
+/**
+ * Release a pooled bead
+ */
+declare function releaseBead(bead: PooledBead): void;
+/**
+ * Acquire a pooled step
+ */
+declare function acquireStep(): PooledStep;
+/**
+ * Release a pooled step
+ */
+declare function releaseStep(step: PooledStep): void;
+/**
+ * Acquire a pooled formula
+ */
+declare function acquireFormula(): PooledFormula;
+/**
+ * Release a pooled formula
+ */
+declare function releaseFormula(formula: PooledFormula): void;
+/**
+ * Acquire a pooled convoy
+ */
+declare function acquireConvoy(): PooledConvoy;
+/**
+ * Release a pooled convoy
+ */
+declare function releaseConvoy(convoy: PooledConvoy): void;
+/**
+ * Acquire a pooled molecule
+ */
+declare function acquireMolecule(): PooledMolecule;
+/**
+ * Release a pooled molecule
+ */
+declare function releaseMolecule(molecule: PooledMolecule): void;
+
+/**
+ * Convoy Observer
+ *
+ * Monitors convoy completion by observing issue state changes
+ * and detecting when all tracked issues are complete. Uses
+ * WASM-accelerated graph analysis for dependency resolution.
+ *
+ * Features:
+ * - Watch convoys for completion
+ * - Detect blocking issues
+ * - Identify ready-to-work issues
+ * - WASM-accelerated dependency graph analysis
+ * - Configurable polling intervals
+ *
+ * @module gastown-bridge/convoy/observer
+ */
+
+/**
+ * WASM graph module interface
+ */
+interface WasmGraphModule {
+    /** Check if dependency graph has cycles */
+    has_cycle(beadsJson: string): boolean;
+    /** Find nodes participating in cycles */
+    find_cycle_nodes(beadsJson: string): string;
+    /** Get beads with no unresolved dependencies */
+    get_ready_beads(beadsJson: string): string;
+    /** Compute execution levels for parallel processing */
+    compute_levels(beadsJson: string): string;
+    /** Topological sort of beads */
+    topo_sort(beadsJson: string): string;
+    /** Critical path analysis */
+    critical_path(beadsJson: string): string;
+}
+/**
+ * Completion callback signature
+ */
+type CompletionCallback = (convoy: Convoy, allComplete: boolean) => void;
+/**
+ * Observer watch handle
+ */
+interface WatchHandle {
+    /** Convoy ID being watched */
+    convoyId: string;
+    /** Stop watching */
+    stop(): void;
+    /** Check if still watching */
+    isActive(): boolean;
+}
+/**
+ * Observer configuration
+ */
+interface ConvoyObserverConfig {
+    /** BD bridge instance */
+    bdBridge: BdBridge;
+    /** Convoy tracker instance */
+    tracker: ConvoyTracker;
+    /** Optional WASM graph module */
+    wasmModule?: WasmGraphModule;
+    /** Initial polling interval in milliseconds */
+    pollInterval?: number;
+    /** Maximum poll attempts before giving up */
+    maxPollAttempts?: number;
+    /** Enable WASM acceleration (falls back to JS if unavailable) */
+    useWasm?: boolean;
+    /** Enable exponential backoff for polling */
+    useExponentialBackoff?: boolean;
+    /** Maximum backoff interval in milliseconds */
+    maxBackoffInterval?: number;
+    /** Backoff multiplier (default: 1.5) */
+    backoffMultiplier?: number;
+    /** Enable delta-based updates (only emit on changes) */
+    deltaUpdatesOnly?: boolean;
+    /** Debounce interval for progress updates in milliseconds */
+    progressDebounceMs?: number;
+}
+/**
+ * Blocker information
+ */
+interface BlockerInfo {
+    /** Issue ID that is blocked */
+    blockedIssue: string;
+    /** Issue IDs that are blocking */
+    blockers: string[];
+    /** True if blockers are from within the convoy */
+    internalBlockers: boolean;
+}
+/**
+ * Ready issue information
+ */
+interface ReadyIssueInfo {
+    /** Issue ID */
+    id: string;
+    /** Issue title */
+    title: string;
+    /** Priority */
+    priority: number;
+    /** Execution level (for parallel processing) */
+    level: number;
+}
+/**
+ * Completion check result
+ */
+interface CompletionCheckResult {
+    /** True if all issues are complete */
+    allComplete: boolean;
+    /** Progress statistics */
+    progress: ConvoyProgress;
+    /** Issues that are still open */
+    openIssues: string[];
+    /** Issues that are in progress */
+    inProgressIssues: string[];
+    /** Issues that are blocked */
+    blockedIssues: BlockerInfo[];
+    /** Issues ready to work on */
+    readyIssues: ReadyIssueInfo[];
+    /** True if there are dependency cycles */
+    hasCycles: boolean;
+    /** Issues involved in cycles */
+    cycleIssues: string[];
+}
+/**
+ * Logger interface
+ */
+interface ObserverLogger {
+    debug: (msg: string, meta?: Record<string, unknown>) => void;
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Convoy Observer
+ *
+ * Monitors convoys for completion and provides dependency analysis.
+ *
+ * @example
+ * ```typescript
+ * const observer = new ConvoyObserver({
+ *   bdBridge,
+ *   tracker,
+ *   pollInterval: 5000,
+ *   useWasm: true,
+ * });
+ *
+ * // Watch for completion
+ * const handle = observer.watch(convoyId, (convoy, complete) => {
+ *   if (complete) {
+ *     console.log('Convoy complete!');
+ *   }
+ * });
+ *
+ * // Check blockers
+ * const blockers = await observer.getBlockers(convoyId);
+ *
+ * // Get ready issues
+ * const ready = await observer.getReadyIssues(convoyId);
+ *
+ * // Stop watching
+ * handle.stop();
+ * ```
+ */
+declare class ConvoyObserver extends EventEmitter {
+    private bdBridge;
+    private tracker;
+    private wasmModule?;
+    private logger;
+    private config;
+    private watchers;
+    private readonly beadCache;
+    private readonly completionCache;
+    private readonly fetchDedup;
+    private readonly progressEmitters;
+    private pendingSubscriptions;
+    private subscriptionFlushTimer;
+    constructor(config: ConvoyObserverConfig, logger?: ObserverLogger);
+    /**
+     * Watch a convoy for completion
+     *
+     * @param convoyId - Convoy ID to watch
+     * @param callback - Called on each check with completion status
+     * @returns Watch handle to stop watching
+     */
+    watch(convoyId: string, callback: CompletionCallback): WatchHandle;
+    /**
+     * Batch subscribe to multiple convoys
+     * Subscriptions are batched and flushed together for efficiency
+     *
+     * @param convoyId - Convoy ID to watch
+     * @param callback - Callback for completion status
+     */
+    batchSubscribe(convoyId: string, callback: CompletionCallback): void;
+    /**
+     * Flush pending subscriptions
+     */
+    private flushSubscriptions;
+    /**
+     * Check if all issues in a convoy are complete
+     *
+     * @param convoyId - Convoy ID
+     * @returns Completion check result with detailed status
+     */
+    checkCompletion(convoyId: string): Promise<CompletionCheckResult>;
+    /**
+     * Get blockers for all issues in a convoy
+     *
+     * @param convoyId - Convoy ID
+     * @returns Array of blocker information
+     */
+    getBlockers(convoyId: string): Promise<BlockerInfo[]>;
+    /**
+     * Get issues ready to work on (no unresolved dependencies)
+     *
+     * @param convoyId - Convoy ID
+     * @returns Array of ready issue information
+     */
+    getReadyIssues(convoyId: string): Promise<ReadyIssueInfo[]>;
+    /**
+     * Get execution order for convoy issues
+     *
+     * @param convoyId - Convoy ID
+     * @returns Ordered array of issue IDs
+     */
+    getExecutionOrder(convoyId: string): Promise<string[]>;
+    /**
+     * Stop watching a convoy
+     */
+    stopWatching(convoyId: string): void;
+    /**
+     * Stop all watchers
+     */
+    stopAll(): void;
+    /**
+     * Set WASM module
+     */
+    setWasmModule(module: WasmGraphModule): void;
+    /**
+     * Check if WASM is available
+     */
+    isWasmAvailable(): boolean;
+    /**
+     * Poll convoy for completion with exponential backoff
+     */
+    private pollConvoyWithBackoff;
+    /**
+     * Legacy poll convoy method (without backoff)
+     * @deprecated Use pollConvoyWithBackoff instead
+     */
+    private pollConvoy;
+    /**
+     * Fetch beads by IDs with caching, batch deduplication, and object pooling.
+     * Uses PooledBead from memory module for reduced allocations.
+     */
+    private fetchBeads;
+    /**
+     * Map CLI bead type to Gas Town status
+     */
+    private mapBeadStatus;
+    /**
+     * Convert beads to WASM node format
+     */
+    private beadsToWasmNodes;
+    /**
+     * Analyze dependencies with WASM
+     */
+    private analyzeWithWasm;
+    /**
+     * Analyze dependencies with JavaScript (fallback)
+     */
+    private analyzeWithJS;
+    /**
+     * Detect cycles using DFS (JavaScript)
+     */
+    private detectCyclesJS;
+    /**
+     * Find nodes in cycles (JavaScript)
+     */
+    private findCycleNodesJS;
+    /**
+     * Topological sort using Kahn's algorithm (JavaScript)
+     */
+    private topoSortJS;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+/**
+ * Create a new convoy observer instance
+ */
+declare function createConvoyObserver(config: ConvoyObserverConfig, logger?: ObserverLogger): ConvoyObserver;
+/**
+ * Create a lazy-initialized convoy observer.
+ * The observer is only created when first accessed (via watch() or checkCompletion()).
+ * Useful for deferring initialization until convoy monitoring is actually needed.
+ *
+ * @example
+ * ```typescript
+ * const lazyObserver = createLazyConvoyObserver(config);
+ *
+ * // Observer is NOT created yet
+ * console.log(lazyObserver.getWatchCount()); // 0
+ *
+ * // First watch triggers observer creation
+ * const observer = await lazyObserver.watch();
+ * const handle = observer.watch(convoyId, callback);
+ *
+ * // When done, unwatch to potentially dispose
+ * await lazyObserver.unwatch();
+ * ```
+ */
+declare function createLazyConvoyObserver(config: ConvoyObserverConfig, logger?: ObserverLogger): LazyObserver<ConvoyObserver>;
+/**
+ * Get lazy observer statistics
+ */
+declare function getLazyObserverStats(lazyObserver: LazyObserver<ConvoyObserver>): {
+    isActive: boolean;
+    watchCount: number;
+};
+
+/**
+ * Gas Town Bridge Plugin - MCP Tools
+ *
+ * Implements 20 MCP tools for Gas Town orchestrator integration:
+ *
+ * Beads Integration (5 tools) - CLI Bridge:
+ *   1. gt_beads_create - Create a bead/issue in Beads
+ *   2. gt_beads_ready - List ready beads (no blockers)
+ *   3. gt_beads_show - Show bead details
+ *   4. gt_beads_dep - Manage bead dependencies
+ *   5. gt_beads_sync - Sync beads with AgentDB
+ *
+ * Convoy Operations (3 tools) - CLI Bridge:
+ *   6. gt_convoy_create - Create a convoy (work order)
+ *   7. gt_convoy_status - Check convoy status
+ *   8. gt_convoy_track - Add/remove issues from convoy
+ *
+ * Formula Engine (4 tools) - WASM Accelerated:
+ *   9. gt_formula_list - List available formulas
+ *   10. gt_formula_cook - Cook formula into protomolecule (352x faster)
+ *   11. gt_formula_execute - Execute a formula
+ *   12. gt_formula_create - Create custom formula
+ *
+ * Orchestration (3 tools) - CLI Bridge:
+ *   13. gt_sling - Sling work to an agent
+ *   14. gt_agents - List Gas Town agents
+ *   15. gt_mail - Send/receive Gas Town mail
+ *
+ * WASM Computation (5 tools) - Pure WASM:
+ *   16. gt_wasm_parse_formula - Parse TOML formula to AST
+ *   17. gt_wasm_resolve_deps - Resolve dependency graph
+ *   18. gt_wasm_cook_batch - Batch cook multiple formulas
+ *   19. gt_wasm_match_pattern - Find similar formulas/beads
+ *   20. gt_wasm_optimize_convoy - Optimize convoy execution order
+ *
+ * Based on ADR-043: Gas Town Bridge Plugin for Claude Flow V3
+ *
+ * @module v3/plugins/gastown-bridge/mcp-tools
+ */
+
+/**
+ * MCP Tool definition
+ */
+interface MCPTool<TInput = unknown, TOutput = unknown> {
+    /** Tool name (e.g., "gt_beads_create") */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** Tool category */
+    category: string;
+    /** Tool version */
+    version: string;
+    /** Execution layer (cli, wasm, hybrid) */
+    layer: 'cli' | 'wasm' | 'hybrid';
+    /** Input schema */
+    inputSchema: z.ZodType<TInput, z.ZodTypeDef, unknown>;
+    /** Handler function */
+    handler: (input: TInput, context: ToolContext) => Promise<MCPToolResult<TOutput>>;
+}
+/**
+ * Tool execution context
+ */
+interface ToolContext {
+    /** Key-value store for cross-tool state */
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    /** Bridge instances */
+    bridges: {
+        gastown: IGasTownBridge$1;
+        beadsSync: IBeadsSyncService;
+        formulaWasm: IFormulaWasm;
+        dependencyWasm: IDependencyWasm;
+    };
+    /** Configuration */
+    config: {
+        townRoot: string;
+        allowedRigs: string[];
+        maxBeadsLimit: number;
+        maskSecrets: boolean;
+        enableWasm: boolean;
+    };
+}
+/**
+ * MCP Tool result format
+ */
+interface MCPToolResult<T = unknown> {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    data?: T;
+}
+/**
+ * All Gas Town Bridge MCP Tools (20 total)
+ */
+declare const gasTownBridgeTools: MCPTool[];
+/**
+ * Tool name to handler map
+ */
+declare const toolHandlers: Map<string, (input: unknown, context: ToolContext) => Promise<MCPToolResult<unknown>>>;
+/**
+ * Tool categories for documentation
+ */
+declare const toolCategories: {
+    beads: string[];
+    convoy: string[];
+    formula: string[];
+    orchestration: string[];
+    wasm: string[];
+};
+/**
+ * Get tool by name
+ */
+declare function getTool(name: string): MCPTool | undefined;
+/**
+ * Get tools by layer
+ */
+declare function getToolsByLayer(layer: 'cli' | 'wasm' | 'hybrid'): MCPTool[];
+
+/**
+ * Gas Town Bridge Plugin - WASM Loader
+ *
+ * Provides lazy-loading and caching for WASM modules with graceful
+ * JavaScript fallback. Includes typed wrapper functions for all WASM exports
+ * and performance timing for benchmarks.
+ *
+ * WASM Modules:
+ * - gastown-formula-wasm: TOML parsing and formula cooking (352x faster)
+ * - ruvector-gnn-wasm: Graph operations and neural network (150x faster)
+ *
+ * @module gastown-bridge/wasm-loader
+ * @version 0.1.0
+ */
+
+/**
+ * Performance timing result
+ */
+interface PerformanceTiming {
+    /** Operation name */
+    readonly operation: string;
+    /** Duration in milliseconds */
+    readonly durationMs: number;
+    /** Whether WASM was used */
+    readonly usedWasm: boolean;
+    /** Timestamp when operation started */
+    readonly startedAt: number;
+}
+/**
+ * WASM module exports for gastown-formula-wasm
+ */
+interface FormulaWasmExports {
+    /** Initialize the WASM module */
+    default?: () => Promise<void>;
+    /** Parse TOML content to Formula AST */
+    parse_toml: (content: string) => string;
+    /** Cook a formula with variable substitution */
+    cook_formula: (formulaJson: string, varsJson: string) => string;
+    /** Batch cook multiple formulas */
+    cook_batch: (formulasJson: string, varsArrayJson: string) => string;
+    /** Get WASM version */
+    version: () => string;
+}
+/**
+ * WASM module exports for ruvector-gnn-wasm
+ */
+interface GnnWasmExports {
+    /** Initialize the WASM module */
+    default?: () => Promise<void>;
+    /** Topological sort of dependency graph */
+    topo_sort: (nodesJson: string, edgesJson: string) => string;
+    /** Detect cycles in dependency graph */
+    detect_cycles: (nodesJson: string, edgesJson: string) => string;
+    /** Calculate critical path */
+    critical_path: (nodesJson: string, edgesJson: string, weightsJson: string) => string;
+    /** Get WASM version */
+    version: () => string;
+}
+/**
+ * Graph edge representation
+ */
+interface GraphEdge {
+    readonly from: string;
+    readonly to: string;
+}
+/**
+ * Node weight for critical path calculation
+ */
+interface NodeWeight {
+    readonly nodeId: string;
+    readonly weight: number;
+}
+/**
+ * Cycle detection result
+ */
+interface CycleDetectionResult {
+    readonly hasCycle: boolean;
+    readonly cycleNodes: string[];
+}
+/**
+ * Check if WASM is available in the current environment.
+ *
+ * @returns True if WASM is supported, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isWasmAvailable()) {
+ *   console.log('WASM acceleration enabled');
+ * } else {
+ *   console.log('Using JavaScript fallback');
+ * }
+ * ```
+ */
+declare function isWasmAvailable(): boolean;
+/**
+ * Get performance log for benchmarking.
+ *
+ * @returns Array of performance timing records
+ *
+ * @example
+ * ```typescript
+ * const timings = getPerformanceLog();
+ * const avgWasmTime = timings
+ *   .filter(t => t.usedWasm)
+ *   .reduce((acc, t) => acc + t.durationMs, 0) / timings.length;
+ * ```
+ */
+declare function getPerformanceLog(): readonly PerformanceTiming[];
+/**
+ * Clear performance log.
+ */
+declare function clearPerformanceLog(): void;
+/**
+ * Lazy-load the gastown-formula-wasm module.
+ * Uses LazyWasm for true lazy loading - only loads when first accessed.
+ * Includes idle timeout for automatic memory cleanup.
+ *
+ * @returns The loaded WASM module exports, or null if unavailable
+ *
+ * @example
+ * ```typescript
+ * const formulaWasm = await loadFormulaWasm();
+ * if (formulaWasm) {
+ *   const result = formulaWasm.parse_toml(tomlContent);
+ * }
+ * ```
+ */
+declare function loadFormulaWasm(): Promise<FormulaWasmExports | null>;
+/**
+ * Lazy-load the ruvector-gnn-wasm module.
+ * Uses LazyWasm for true lazy loading - only loads when first accessed.
+ * Includes idle timeout for automatic memory cleanup.
+ *
+ * @returns The loaded WASM module exports, or null if unavailable
+ *
+ * @example
+ * ```typescript
+ * const gnnWasm = await loadGnnWasm();
+ * if (gnnWasm) {
+ *   const result = gnnWasm.topo_sort(nodesJson, edgesJson);
+ * }
+ * ```
+ */
+declare function loadGnnWasm(): Promise<GnnWasmExports | null>;
+/**
+ * Check if formula WASM module is currently loaded.
+ * Does not trigger loading.
+ */
+declare function isFormulaWasmLoaded(): boolean;
+/**
+ * Check if GNN WASM module is currently loaded.
+ * Does not trigger loading.
+ */
+declare function isGnnWasmLoaded(): boolean;
+/**
+ * Get lazy loading statistics for WASM modules.
+ */
+declare function getWasmLazyStats(): {
+    formulaWasm: LazyStats;
+    gnnWasm: LazyStats;
+};
+/**
+ * Parse TOML formula content to a Formula object.
+ * Uses WASM if available (352x faster), falls back to JavaScript.
+ *
+ * @param content - TOML string content to parse
+ * @returns Parsed Formula object
+ *
+ * @example
+ * ```typescript
+ * const formula = await parseFormula(`
+ * name = "my-workflow"
+ * type = "workflow"
+ * version = 1
+ *
+ * [[steps]]
+ * id = "step-1"
+ * title = "First step"
+ * `);
+ * ```
+ */
+declare function parseFormula(content: string): Promise<Formula>;
+/**
+ * Cook a formula by substituting variables.
+ * Uses WASM if available (352x faster), falls back to JavaScript.
+ *
+ * @param formula - Formula to cook
+ * @param vars - Variables to substitute
+ * @returns Cooked formula with variables substituted
+ *
+ * @example
+ * ```typescript
+ * const cooked = await cookFormula(formula, {
+ *   projectName: 'my-project',
+ *   author: 'developer'
+ * });
+ * ```
+ */
+declare function cookFormula(formula: Formula, vars: Record<string, string>): Promise<Formula>;
+/**
+ * Batch cook multiple formulas with corresponding variables.
+ * Uses WASM if available (352x faster), falls back to JavaScript.
+ *
+ * @param formulas - Array of formulas to cook
+ * @param varsArray - Array of variable objects (one per formula)
+ * @returns Array of cooked formulas
+ *
+ * @example
+ * ```typescript
+ * const cooked = await cookBatch(
+ *   [formula1, formula2],
+ *   [{ name: 'a' }, { name: 'b' }]
+ * );
+ * ```
+ */
+declare function cookBatch(formulas: Formula[], varsArray: Record<string, string>[]): Promise<Formula[]>;
+/**
+ * Perform topological sort on a dependency graph.
+ * Uses WASM if available (150x faster), falls back to JavaScript.
+ *
+ * @param nodes - Array of node identifiers
+ * @param edges - Array of edges (from -> to dependencies)
+ * @returns Topological sort result with sorted order and cycle detection
+ *
+ * @example
+ * ```typescript
+ * const result = await topoSort(
+ *   ['a', 'b', 'c'],
+ *   [{ from: 'a', to: 'b' }, { from: 'b', to: 'c' }]
+ * );
+ * console.log(result.sorted); // ['a', 'b', 'c']
+ * ```
+ */
+declare function topoSort(nodes: string[], edges: GraphEdge[]): Promise<TopoSortResult>;
+/**
+ * Detect cycles in a dependency graph.
+ * Uses WASM if available (150x faster), falls back to JavaScript.
+ *
+ * @param nodes - Array of node identifiers
+ * @param edges - Array of edges (from -> to dependencies)
+ * @returns Cycle detection result
+ *
+ * @example
+ * ```typescript
+ * const result = await detectCycles(
+ *   ['a', 'b', 'c'],
+ *   [{ from: 'a', to: 'b' }, { from: 'b', to: 'a' }]
+ * );
+ * console.log(result.hasCycle); // true
+ * console.log(result.cycleNodes); // ['a', 'b']
+ * ```
+ */
+declare function detectCycles(nodes: string[], edges: GraphEdge[]): Promise<CycleDetectionResult>;
+/**
+ * Calculate the critical path through a weighted dependency graph.
+ * Uses WASM if available (150x faster), falls back to JavaScript.
+ *
+ * @param nodes - Array of node identifiers
+ * @param edges - Array of edges (from -> to dependencies)
+ * @param weights - Array of node weights (durations)
+ * @returns Critical path result with path, duration, and slack times
+ *
+ * @example
+ * ```typescript
+ * const result = await criticalPath(
+ *   ['a', 'b', 'c'],
+ *   [{ from: 'a', to: 'b' }, { from: 'b', to: 'c' }],
+ *   [
+ *     { nodeId: 'a', weight: 5 },
+ *     { nodeId: 'b', weight: 3 },
+ *     { nodeId: 'c', weight: 2 }
+ *   ]
+ * );
+ * console.log(result.path); // ['a', 'b', 'c']
+ * console.log(result.totalDuration); // 10
+ * ```
+ */
+declare function criticalPath(nodes: string[], edges: GraphEdge[], weights: NodeWeight[]): Promise<CriticalPathResult>;
+/**
+ * Preload all WASM modules.
+ * Call this during initialization for best performance.
+ *
+ * @returns Object indicating which modules were loaded
+ *
+ * @example
+ * ```typescript
+ * const status = await preloadWasmModules();
+ * console.log(status);
+ * // { formulaWasm: true, gnnWasm: true }
+ * ```
+ */
+declare function preloadWasmModules(): Promise<{
+    formulaWasm: boolean;
+    gnnWasm: boolean;
+}>;
+/**
+ * Get WASM module versions.
+ *
+ * @returns Object with version strings, or null if module not loaded
+ */
+declare function getWasmVersions(): Promise<{
+    formulaWasm: string | null;
+    gnnWasm: string | null;
+}>;
+/**
+ * Reset the WASM module cache.
+ * Clears lazy loader cache and forces reload on next access.
+ * Useful for testing or when modules need to be reloaded.
+ */
+declare function resetWasmCache(): void;
+/**
+ * Schedule idle-time preloading of WASM modules.
+ * Uses requestIdleCallback in browser, setImmediate in Node.
+ * Does not block the main thread.
+ *
+ * @example
+ * ```typescript
+ * // Call during app initialization
+ * scheduleIdlePreload();
+ * ```
+ */
+declare function scheduleIdlePreload(): void;
+/**
+ * Get cache statistics for performance monitoring.
+ *
+ * @returns Object with cache stats for each cache type
+ *
+ * @example
+ * ```typescript
+ * const stats = getCacheStats();
+ * console.log(`Parse cache: ${stats.parseCache.entries} entries`);
+ * console.log(`Cook cache hit rate: ${stats.cookCache.hitRate}`);
+ * ```
+ */
+declare function getCacheStats(): {
+    parseCache: {
+        entries: number;
+        sizeBytes: number;
+        hitRate: number;
+    };
+    cookCache: {
+        entries: number;
+        sizeBytes: number;
+        hitRate: number;
+    };
+    topoSortCache: {
+        entries: number;
+        sizeBytes: number;
+        hitRate: number;
+    };
+    astCache: {
+        entries: number;
+        sizeBytes: number;
+    };
+    preloader: {
+        queued: number;
+        loaded: number;
+        errors: number;
+        isPreloading: boolean;
+    };
+    deduplicator: {
+        parsePending: number;
+        cookPending: number;
+        graphPending: number;
+    };
+};
+/**
+ * Clear all result caches.
+ * Useful for testing or when formulas have been modified.
+ */
+declare function clearAllCaches(): void;
+declare const _default: {
+    isWasmAvailable: typeof isWasmAvailable;
+    loadFormulaWasm: typeof loadFormulaWasm;
+    parseFormula: typeof parseFormula;
+    cookFormula: typeof cookFormula;
+    cookBatch: typeof cookBatch;
+    loadGnnWasm: typeof loadGnnWasm;
+    topoSort: typeof topoSort;
+    detectCycles: typeof detectCycles;
+    criticalPath: typeof criticalPath;
+    preloadWasmModules: typeof preloadWasmModules;
+    getWasmVersions: typeof getWasmVersions;
+    resetWasmCache: typeof resetWasmCache;
+    isFormulaWasmLoaded: typeof isFormulaWasmLoaded;
+    isGnnWasmLoaded: typeof isGnnWasmLoaded;
+    getWasmLazyStats: typeof getWasmLazyStats;
+    scheduleIdlePreload: typeof scheduleIdlePreload;
+    getCacheStats: typeof getCacheStats;
+    clearAllCaches: typeof clearAllCaches;
+    getPerformanceLog: typeof getPerformanceLog;
+    clearPerformanceLog: typeof clearPerformanceLog;
+};
+
+/**
+ * Gas Town Bridge Plugin - Typed Error Classes
+ *
+ * Provides a hierarchy of typed error classes for the Gas Town Bridge Plugin:
+ * - GasTownError: Base error class for all Gas Town errors
+ * - BeadsError: Errors related to bead operations
+ * - ValidationError: Input validation failures
+ * - CLIExecutionError: CLI command execution failures
+ *
+ * All errors include:
+ * - Typed error codes for programmatic handling
+ * - Stack traces for debugging
+ * - Contextual information about the failure
+ *
+ * @module gastown-bridge/errors
+ * @version 0.1.0
+ */
+/**
+ * Gas Town error codes enumeration
+ */
+declare const GasTownErrorCode: {
+    readonly UNKNOWN: "GT_UNKNOWN";
+    readonly INITIALIZATION_FAILED: "GT_INITIALIZATION_FAILED";
+    readonly NOT_INITIALIZED: "GT_NOT_INITIALIZED";
+    readonly CONFIGURATION_ERROR: "GT_CONFIGURATION_ERROR";
+    readonly VALIDATION_FAILED: "GT_VALIDATION_FAILED";
+    readonly INVALID_INPUT: "GT_INVALID_INPUT";
+    readonly INVALID_BEAD_ID: "GT_INVALID_BEAD_ID";
+    readonly INVALID_FORMULA_NAME: "GT_INVALID_FORMULA_NAME";
+    readonly INVALID_CONVOY_ID: "GT_INVALID_CONVOY_ID";
+    readonly INVALID_ARGUMENTS: "GT_INVALID_ARGUMENTS";
+    readonly COMMAND_INJECTION_DETECTED: "GT_COMMAND_INJECTION_DETECTED";
+    readonly PATH_TRAVERSAL_DETECTED: "GT_PATH_TRAVERSAL_DETECTED";
+    readonly BEAD_NOT_FOUND: "GT_BEAD_NOT_FOUND";
+    readonly BEAD_CREATE_FAILED: "GT_BEAD_CREATE_FAILED";
+    readonly BEAD_UPDATE_FAILED: "GT_BEAD_UPDATE_FAILED";
+    readonly BEAD_DELETE_FAILED: "GT_BEAD_DELETE_FAILED";
+    readonly BEAD_PARSE_FAILED: "GT_BEAD_PARSE_FAILED";
+    readonly FORMULA_NOT_FOUND: "GT_FORMULA_NOT_FOUND";
+    readonly FORMULA_PARSE_FAILED: "GT_FORMULA_PARSE_FAILED";
+    readonly FORMULA_COOK_FAILED: "GT_FORMULA_COOK_FAILED";
+    readonly FORMULA_INVALID_TYPE: "GT_FORMULA_INVALID_TYPE";
+    readonly CONVOY_NOT_FOUND: "GT_CONVOY_NOT_FOUND";
+    readonly CONVOY_CREATE_FAILED: "GT_CONVOY_CREATE_FAILED";
+    readonly CLI_NOT_FOUND: "GT_CLI_NOT_FOUND";
+    readonly CLI_TIMEOUT: "GT_CLI_TIMEOUT";
+    readonly CLI_EXECUTION_FAILED: "GT_CLI_EXECUTION_FAILED";
+    readonly CLI_INVALID_OUTPUT: "GT_CLI_INVALID_OUTPUT";
+    readonly WASM_NOT_AVAILABLE: "GT_WASM_NOT_AVAILABLE";
+    readonly WASM_EXECUTION_FAILED: "GT_WASM_EXECUTION_FAILED";
+    readonly SYNC_FAILED: "GT_SYNC_FAILED";
+    readonly SYNC_CONFLICT: "GT_SYNC_CONFLICT";
+    readonly DEPENDENCY_CYCLE: "GT_DEPENDENCY_CYCLE";
+    readonly GRAPH_ERROR: "GT_GRAPH_ERROR";
+};
+type GasTownErrorCodeType = (typeof GasTownErrorCode)[keyof typeof GasTownErrorCode];
+/**
+ * Base error class for all Gas Town Bridge errors
+ *
+ * @example
+ * ```typescript
+ * throw new GasTownError(
+ *   'Failed to initialize plugin',
+ *   GasTownErrorCode.INITIALIZATION_FAILED,
+ *   { configPath: '/path/to/config' }
+ * );
+ * ```
+ */
+declare class GasTownError extends Error {
+    /** Error code for programmatic handling */
+    readonly code: GasTownErrorCodeType;
+    /** Timestamp when error occurred */
+    readonly timestamp: Date;
+    /** Additional context about the error */
+    readonly context?: Record<string, unknown>;
+    /** Original error if this wraps another error */
+    readonly cause?: Error;
+    constructor(message: string, code?: GasTownErrorCodeType, context?: Record<string, unknown>, cause?: Error);
+    /**
+     * Convert error to JSON for logging/serialization
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Create a human-readable string representation
+     */
+    toString(): string;
+}
+/**
+ * Error class for bead-related operations
+ *
+ * @example
+ * ```typescript
+ * throw new BeadsError(
+ *   'Bead not found',
+ *   GasTownErrorCode.BEAD_NOT_FOUND,
+ *   { beadId: 'gt-abc12' }
+ * );
+ * ```
+ */
+declare class BeadsError extends GasTownError {
+    /** Bead ID if applicable */
+    readonly beadId?: string;
+    /** Operation being performed */
+    readonly operation?: string;
+    constructor(message: string, code?: GasTownErrorCodeType, context?: Record<string, unknown>, cause?: Error);
+    /**
+     * Create a BeadsError for a not found scenario
+     */
+    static notFound(beadId: string): BeadsError;
+    /**
+     * Create a BeadsError for a create failure
+     */
+    static createFailed(reason: string, cause?: Error): BeadsError;
+    /**
+     * Create a BeadsError for a parse failure
+     */
+    static parseFailed(rawOutput: string, cause?: Error): BeadsError;
+}
+/**
+ * Validation constraint that was violated
+ */
+interface ValidationConstraint {
+    /** Field or parameter that failed validation */
+    field: string;
+    /** Expected constraint (e.g., "alphanumeric", "max-length:64") */
+    constraint: string;
+    /** Actual value (sanitized for logging) */
+    actual?: string;
+    /** Expected value or pattern */
+    expected?: string;
+}
+/**
+ * Error class for input validation failures
+ *
+ * @example
+ * ```typescript
+ * throw new ValidationError(
+ *   'Invalid bead ID format',
+ *   GasTownErrorCode.INVALID_BEAD_ID,
+ *   [{ field: 'beadId', constraint: 'alphanumeric', actual: 'abc;rm -rf' }]
+ * );
+ * ```
+ */
+declare class ValidationError extends GasTownError {
+    /** Validation constraints that were violated */
+    readonly constraints: ValidationConstraint[];
+    constructor(message: string, code?: GasTownErrorCodeType, constraints?: ValidationConstraint[], cause?: Error);
+    /**
+     * Create a ValidationError for an invalid bead ID
+     */
+    static invalidBeadId(beadId: string): ValidationError;
+    /**
+     * Create a ValidationError for an invalid formula name
+     */
+    static invalidFormulaName(name: string): ValidationError;
+    /**
+     * Create a ValidationError for an invalid convoy ID
+     */
+    static invalidConvoyId(convoyId: string): ValidationError;
+    /**
+     * Create a ValidationError for command injection attempt
+     */
+    static commandInjection(field: string, detected: string): ValidationError;
+    /**
+     * Create a ValidationError for path traversal attempt
+     */
+    static pathTraversal(field: string): ValidationError;
+    /**
+     * Combine multiple validation errors
+     */
+    static combine(errors: ValidationError[]): ValidationError;
+}
+/**
+ * Error class for CLI command execution failures
+ *
+ * @example
+ * ```typescript
+ * throw new CLIExecutionError(
+ *   'gt command failed',
+ *   GasTownErrorCode.CLI_EXECUTION_FAILED,
+ *   { command: 'gt', args: ['beads', 'list'], exitCode: 1, stderr: 'error message' }
+ * );
+ * ```
+ */
+declare class CLIExecutionError extends GasTownError {
+    /** CLI command that was executed */
+    readonly command: string;
+    /** Arguments passed to the command (sanitized) */
+    readonly args: string[];
+    /** Exit code from the process */
+    readonly exitCode?: number;
+    /** Standard error output (truncated) */
+    readonly stderr?: string;
+    /** Execution duration in milliseconds */
+    readonly durationMs?: number;
+    constructor(message: string, code: GasTownErrorCodeType | undefined, details: {
+        command: string;
+        args?: string[];
+        exitCode?: number;
+        stderr?: string;
+        durationMs?: number;
+    }, cause?: Error);
+    /**
+     * Create a CLIExecutionError for command not found
+     */
+    static notFound(command: string): CLIExecutionError;
+    /**
+     * Create a CLIExecutionError for timeout
+     */
+    static timeout(command: string, args: string[], timeoutMs: number): CLIExecutionError;
+    /**
+     * Create a CLIExecutionError for execution failure
+     */
+    static failed(command: string, args: string[], exitCode: number, stderr: string, durationMs?: number): CLIExecutionError;
+    /**
+     * Create a CLIExecutionError for invalid output
+     */
+    static invalidOutput(command: string, reason: string): CLIExecutionError;
+}
+/**
+ * Error class for formula-related operations
+ */
+declare class FormulaError extends GasTownError {
+    /** Formula name if applicable */
+    readonly formulaName?: string;
+    /** Formula type if applicable */
+    readonly formulaType?: string;
+    constructor(message: string, code?: GasTownErrorCodeType, context?: Record<string, unknown>, cause?: Error);
+    /**
+     * Create a FormulaError for not found
+     */
+    static notFound(formulaName: string): FormulaError;
+    /**
+     * Create a FormulaError for parse failure
+     */
+    static parseFailed(formulaName: string, reason: string, cause?: Error): FormulaError;
+    /**
+     * Create a FormulaError for cook failure
+     */
+    static cookFailed(formulaName: string, reason: string, cause?: Error): FormulaError;
+}
+/**
+ * Error class for convoy-related operations
+ */
+declare class ConvoyError extends GasTownError {
+    /** Convoy ID if applicable */
+    readonly convoyId?: string;
+    constructor(message: string, code?: GasTownErrorCodeType, context?: Record<string, unknown>, cause?: Error);
+    /**
+     * Create a ConvoyError for not found
+     */
+    static notFound(convoyId: string): ConvoyError;
+    /**
+     * Create a ConvoyError for create failure
+     */
+    static createFailed(reason: string, cause?: Error): ConvoyError;
+}
+/**
+ * Type guard for GasTownError
+ */
+declare function isGasTownError(error: unknown): error is GasTownError;
+/**
+ * Type guard for ValidationError
+ */
+declare function isValidationError(error: unknown): error is ValidationError;
+/**
+ * Type guard for CLIExecutionError
+ */
+declare function isCLIExecutionError(error: unknown): error is CLIExecutionError;
+/**
+ * Type guard for BeadsError
+ */
+declare function isBeadsError(error: unknown): error is BeadsError;
+/**
+ * Wrap an unknown error as a GasTownError
+ */
+declare function wrapError(error: unknown, code?: GasTownErrorCodeType): GasTownError;
+/**
+ * Extract error message safely
+ */
+declare function getErrorMessage(error: unknown): string;
+
+/**
+ * Gas Town Bridge Plugin - Input Validators
+ *
+ * Provides comprehensive input validation for the Gas Town Bridge Plugin:
+ * - validateBeadId: Validate bead IDs (alphanumeric only)
+ * - validateFormulaName: Validate formula names (safe path characters)
+ * - validateConvoyId: Validate convoy IDs (UUID format)
+ * - validateGtArgs: Validate and escape CLI arguments
+ *
+ * Security Features:
+ * - Allowlist-based validation (only permit known-safe patterns)
+ * - Command injection prevention
+ * - Path traversal prevention
+ * - Null byte injection prevention
+ * - Shell metacharacter blocking
+ *
+ * All validators follow OWASP guidelines for input validation.
+ *
+ * @module gastown-bridge/validators
+ * @version 0.1.0
+ */
+
+/**
+ * Shell metacharacters that are never allowed in any input
+ */
+declare const SHELL_METACHARACTERS: RegExp;
+/**
+ * Path traversal patterns
+ */
+declare const PATH_TRAVERSAL_PATTERNS: RegExp[];
+/**
+ * Allowed bead ID formats
+ * - gt-{4-16 alphanumeric chars}
+ * - Numeric IDs (1-10 digits)
+ */
+declare const BEAD_ID_PATTERN: RegExp;
+/**
+ * Allowed formula name format
+ * - Starts with letter
+ * - Contains only alphanumeric, dash, underscore
+ * - 1-64 characters
+ */
+declare const FORMULA_NAME_PATTERN: RegExp;
+/**
+ * UUID v4 pattern for convoy IDs
+ */
+declare const UUID_PATTERN: RegExp;
+/**
+ * Alternative convoy ID format (conv-{hash})
+ */
+declare const CONVOY_HASH_PATTERN: RegExp;
+/**
+ * Maximum lengths for inputs
+ */
+declare const MAX_LENGTHS: {
+    readonly beadId: 32;
+    readonly formulaName: 64;
+    readonly convoyId: 36;
+    readonly argument: 512;
+    readonly stringValue: 4096;
+    readonly arrayLength: 100;
+};
+/**
+ * Schema for bead ID validation
+ */
+declare const BeadIdSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
+/**
+ * Schema for formula name validation
+ */
+declare const FormulaNameSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
+/**
+ * Schema for convoy ID validation (UUID format)
+ */
+declare const ConvoyIdSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+/**
+ * Schema for CLI arguments array
+ */
+declare const GtArgsSchema: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, "many">;
+/**
+ * Schema for safe string values
+ */
+declare const SafeStringSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Schema for rig name
+ */
+declare const RigNameSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+/**
+ * Schema for priority
+ */
+declare const PrioritySchema: z.ZodNumber;
+/**
+ * Schema for labels array
+ */
+declare const LabelsSchema: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+/**
+ * Validate a bead ID
+ *
+ * Accepts:
+ * - gt-{4-16 alphanumeric chars} (e.g., "gt-abc12", "gt-a1b2c3d4")
+ * - Numeric IDs (e.g., "123", "9999999999")
+ *
+ * Rejects:
+ * - Empty strings
+ * - Shell metacharacters
+ * - Path traversal sequences
+ * - Invalid formats
+ *
+ * @param id - The bead ID to validate
+ * @returns The validated and trimmed bead ID
+ * @throws {ValidationError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const validId = validateBeadId('gt-abc12');  // Returns 'gt-abc12'
+ * validateBeadId('gt-abc; rm -rf /');          // Throws ValidationError
+ * ```
+ */
+declare function validateBeadId(id: string): string;
+/**
+ * Validate a formula name
+ *
+ * Accepts:
+ * - Starts with letter
+ * - Contains only alphanumeric, dash, underscore
+ * - 1-64 characters
+ *
+ * Rejects:
+ * - Starting with number
+ * - Shell metacharacters
+ * - Path traversal sequences
+ *
+ * @param name - The formula name to validate
+ * @returns The validated and trimmed formula name
+ * @throws {ValidationError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const validName = validateFormulaName('my-formula');  // Returns 'my-formula'
+ * validateFormulaName('../etc/passwd');                  // Throws ValidationError
+ * ```
+ */
+declare function validateFormulaName(name: string): string;
+/**
+ * Validate a convoy ID
+ *
+ * Accepts:
+ * - UUID v4 format (e.g., "550e8400-e29b-41d4-a716-446655440000")
+ * - conv-{hash} format (e.g., "conv-abc123def")
+ *
+ * Rejects:
+ * - Invalid UUID format
+ * - Shell metacharacters
+ * - Path traversal sequences
+ *
+ * @param id - The convoy ID to validate
+ * @returns The validated and normalized convoy ID (lowercase)
+ * @throws {ValidationError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const validId = validateConvoyId('550e8400-e29b-41d4-a716-446655440000');
+ * validateConvoyId('not-a-uuid');  // Throws ValidationError
+ * ```
+ */
+declare function validateConvoyId(id: string): string;
+/**
+ * Validate and escape CLI arguments
+ *
+ * Validates each argument in the array:
+ * - No null bytes
+ * - No shell metacharacters
+ * - No path traversal sequences
+ * - Maximum length enforced
+ *
+ * @param args - Array of CLI arguments to validate
+ * @returns Array of validated arguments
+ * @throws {ValidationError} If any argument fails validation
+ *
+ * @example
+ * ```typescript
+ * const validArgs = validateGtArgs(['beads', 'list', '--limit', '10']);
+ * validateGtArgs(['rm', '-rf', '/']);  // Throws ValidationError
+ * ```
+ */
+declare function validateGtArgs(args: string[]): string[];
+/**
+ * Schema for CreateBeadOptions
+ */
+declare const CreateBeadOptionsSchema: z.ZodObject<{
+    title: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    labels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>>;
+    parent: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>>;
+    rig: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>>;
+    assignee: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strip", z.ZodTypeAny, {
+    priority: number;
+    title: string;
+    labels: string[];
+    description?: string | undefined;
+    assignee?: string | undefined;
+    rig?: string | undefined;
+    parent?: string | undefined;
+}, {
+    title: string;
+    description?: string | undefined;
+    priority?: number | undefined;
+    assignee?: string | undefined;
+    labels?: string[] | undefined;
+    rig?: string | undefined;
+    parent?: string | undefined;
+}>;
+/**
+ * Schema for CreateConvoyOptions
+ */
+declare const CreateConvoyOptionsSchema: z.ZodObject<{
+    name: z.ZodEffects<z.ZodString, string, string>;
+    issues: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>, "many">;
+    description: z.ZodOptional<z.ZodString>;
+    formula: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    issues: string[];
+    description?: string | undefined;
+    formula?: string | undefined;
+}, {
+    name: string;
+    issues: string[];
+    description?: string | undefined;
+    formula?: string | undefined;
+}>;
+/**
+ * Schema for SlingOptions
+ */
+declare const SlingOptionsSchema: z.ZodObject<{
+    beadId: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
+    target: z.ZodEnum<["polecat", "crew", "mayor"]>;
+    formula: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    beadId: string;
+    target: "mayor" | "polecat" | "crew";
+    priority?: number | undefined;
+    formula?: string | undefined;
+}, {
+    beadId: string;
+    target: "mayor" | "polecat" | "crew";
+    priority?: number | undefined;
+    formula?: string | undefined;
+}>;
+/**
+ * Validate CreateBeadOptions
+ */
+declare function validateCreateBeadOptions(options: unknown): z.infer<typeof CreateBeadOptionsSchema>;
+/**
+ * Validate CreateConvoyOptions
+ */
+declare function validateCreateConvoyOptions(options: unknown): z.infer<typeof CreateConvoyOptionsSchema>;
+/**
+ * Validate SlingOptions
+ */
+declare function validateSlingOptions(options: unknown): z.infer<typeof SlingOptionsSchema>;
+/**
+ * Check if a string contains shell metacharacters
+ */
+declare function containsShellMetacharacters(input: string): boolean;
+/**
+ * Check if a string contains path traversal sequences
+ */
+declare function containsPathTraversal(input: string): boolean;
+/**
+ * Check if a string is safe for use in CLI arguments
+ */
+declare function isSafeArgument(input: string): boolean;
+/**
+ * Check if a bead ID is valid
+ */
+declare function isValidBeadId(id: string): boolean;
+/**
+ * Check if a formula name is valid
+ */
+declare function isValidFormulaName(name: string): boolean;
+/**
+ * Check if a convoy ID is valid
+ */
+declare function isValidConvoyId(id: string): boolean;
+
+/**
+ * Gas Town Bridge Plugin - Output Sanitizers
+ *
+ * Provides output sanitization for the Gas Town Bridge Plugin:
+ * - sanitizeBeadOutput: Parse and sanitize bead CLI output
+ * - sanitizeFormulaOutput: Parse and sanitize formula CLI output
+ * - Remove sensitive data from outputs
+ *
+ * Security Features:
+ * - JSON parsing with validation
+ * - Sensitive field redaction (tokens, keys, passwords)
+ * - Output size limits to prevent DoS
+ * - Type coercion and validation
+ *
+ * All sanitizers follow OWASP guidelines for output encoding.
+ *
+ * @module gastown-bridge/sanitizers
+ * @version 0.1.0
+ */
+
+/**
+ * Maximum output sizes to prevent DoS
+ */
+declare const MAX_OUTPUT_SIZE: {
+    readonly single: number;
+    readonly list: number;
+    readonly field: 65536;
+};
+/**
+ * Sensitive field patterns that should be redacted
+ */
+declare const SENSITIVE_FIELD_PATTERNS: RegExp[];
+/**
+ * Fields that should always be removed from output
+ */
+declare const REDACTED_FIELDS: Set<string>;
+/**
+ * Sanitize raw bead output from CLI
+ *
+ * Parses JSON output, validates structure, redacts sensitive fields,
+ * and normalizes the data to the Bead interface.
+ *
+ * @param raw - Raw string output from CLI
+ * @returns Sanitized Bead object
+ * @throws {BeadsError} If parsing or validation fails
+ *
+ * @example
+ * ```typescript
+ * const bead = sanitizeBeadOutput('{"id":"gt-abc12","title":"Test"}');
+ * console.log(bead.id);  // 'gt-abc12'
+ * ```
+ */
+declare function sanitizeBeadOutput(raw: string): Bead;
+/**
+ * Sanitize raw formula output from CLI
+ *
+ * Parses JSON/TOML output, validates structure, redacts sensitive fields,
+ * and normalizes the data to the Formula interface.
+ *
+ * @param raw - Raw string output from CLI
+ * @returns Sanitized Formula object
+ * @throws {FormulaError} If parsing or validation fails
+ *
+ * @example
+ * ```typescript
+ * const formula = sanitizeFormulaOutput('{"name":"test","type":"workflow"}');
+ * console.log(formula.name);  // 'test'
+ * ```
+ */
+declare function sanitizeFormulaOutput(raw: string): Formula;
+/**
+ * Sanitize raw convoy output from CLI
+ *
+ * @param raw - Raw string output from CLI
+ * @returns Sanitized Convoy object
+ * @throws {ConvoyError} If parsing or validation fails
+ */
+declare function sanitizeConvoyOutput(raw: string): Convoy;
+/**
+ * Sanitize a list of beads from JSONL output
+ *
+ * @param raw - Raw JSONL string (one JSON object per line)
+ * @returns Array of sanitized Bead objects
+ */
+declare function sanitizeBeadsListOutput(raw: string): Bead[];
+/**
+ * Recursively redact sensitive fields from an object
+ */
+declare function redactSensitiveFields(obj: Record<string, unknown>): void;
+/**
+ * Sanitize a string value with length limit
+ */
+declare function sanitizeString(value: string | undefined | null, maxLength: number): string;
+/**
+ * Sanitize a path value (remove traversal sequences)
+ */
+declare function sanitizePath(value: string): string;
+/**
+ * Parse a date value
+ */
+declare function parseDate(value: string | Date | undefined | null): Date | undefined;
+/**
+ * Sanitize metadata object
+ */
+declare function sanitizeMetadata(metadata: Record<string, unknown>): Record<string, unknown>;
+
+/**
+ * Gas Town Bridge Plugin - Main Entry Point
+ *
+ * GasTownBridgePlugin class implementing the IPlugin interface:
+ * - register(): Register with claude-flow plugin system
+ * - initialize(): Load WASM modules, set up bridges
+ * - shutdown(): Cleanup resources
+ *
+ * Provides integration with Steve Yegge's Gas Town orchestrator:
+ * - Beads: Git-backed issue tracking with graph semantics
+ * - Formulas: TOML-defined workflows (convoy, workflow, expansion, aspect)
+ * - Convoys: Work-order tracking for slung work
+ * - WASM: 352x faster formula parsing and graph analysis
+ *
+ * @module gastown-bridge
+ * @version 0.1.0
+ */
+
+/**
+ * Plugin context interface
+ */
+interface PluginContext {
+    get<T>(key: string): T;
+    set<T>(key: string, value: T): void;
+    has(key: string): boolean;
+}
+/**
+ * MCP Tool definition for plugin interface
+ */
+interface PluginMCPTool {
+    name: string;
+    description: string;
+    category: string;
+    version: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    handler: (input: unknown, context: PluginContext) => Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+    }>;
+}
+/**
+ * Hook priority type
+ */
+type HookPriority = number;
+/**
+ * Plugin hook definition
+ */
+interface PluginHook {
+    name: string;
+    event: string;
+    priority: HookPriority;
+    description: string;
+    handler: (context: PluginContext, payload: unknown) => Promise<unknown>;
+}
+/**
+ * Plugin interface
+ */
+interface IPlugin {
+    readonly name: string;
+    readonly version: string;
+    readonly description: string;
+    register(context: PluginContext): Promise<void>;
+    initialize(context: PluginContext): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    shutdown(context: PluginContext): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getCapabilities(): string[];
+    getMCPTools(): PluginMCPTool[];
+    getHooks(): PluginHook[];
+}
+/**
+ * Gas Town CLI bridge interface
+ */
+interface IGasTownBridge {
+    gt(args: string[]): Promise<string>;
+    bd(args: string[]): Promise<string>;
+    createBead(opts: CreateBeadOptions): Promise<Bead>;
+    getReady(limit?: number, rig?: string): Promise<Bead[]>;
+    showBead(beadId: string): Promise<Bead>;
+    addDep(child: string, parent: string): Promise<void>;
+    removeDep(child: string, parent: string): Promise<void>;
+    sling(opts: SlingOptions): Promise<void>;
+}
+/**
+ * Formula engine interface
+ */
+interface IFormulaEngine {
+    parse(content: string): Formula;
+    cook(formula: Formula, vars: Record<string, string>): Formula;
+    toMolecule(formula: Formula, bridge: IGasTownBridge): Promise<string[]>;
+}
+/**
+ * WASM bridge interface
+ */
+interface IWasmBridge {
+    initialize(): Promise<void>;
+    isInitialized(): boolean;
+    dispose(): Promise<void>;
+    parseFormula(content: string): Formula;
+    cookFormula(formula: Formula, vars: Record<string, string>): Formula;
+    resolveDeps(beads: Bead[]): TopoSortResult;
+    detectCycle(graph: BeadGraph): boolean;
+    criticalPath(beads: Bead[], durations: Map<string, number>): CriticalPathResult;
+    batchCook(formulas: Formula[], vars: Record<string, string>[]): Formula[];
+}
+/**
+ * Sync service interface
+ */
+interface ISyncService {
+    pullBeads(rig?: string): Promise<number>;
+    pushTasks(namespace: string): Promise<number>;
+    sync(direction: 'pull' | 'push' | 'both', rig?: string): Promise<SyncResult>;
+}
+/**
+ * Gas Town Bridge Plugin configuration
+ */
+interface GasTownBridgeConfig {
+    /** Base Gas Town configuration */
+    gastown: Partial<GasTownConfig>;
+    /** GtBridge configuration */
+    gtBridge?: {
+        /** Path to gt CLI binary */
+        gtPath?: string;
+        /** CLI execution timeout in ms */
+        timeout?: number;
+        /** Working directory */
+        cwd?: string;
+    };
+    /** BdBridge configuration */
+    bdBridge?: {
+        /** Path to bd CLI binary */
+        bdPath?: string;
+        /** CLI execution timeout in ms */
+        timeout?: number;
+        /** Working directory */
+        cwd?: string;
+    };
+    /** SyncBridge configuration */
+    syncBridge?: {
+        /** AgentDB namespace for beads */
+        namespace?: string;
+        /** Sync interval in ms */
+        syncInterval?: number;
+        /** Enable auto-sync */
+        autoSync?: boolean;
+    };
+    /** FormulaExecutor configuration */
+    formulaExecutor?: {
+        /** Enable WASM acceleration */
+        useWasm?: boolean;
+        /** Step execution timeout in ms */
+        stepTimeout?: number;
+        /** Maximum parallel steps */
+        maxParallel?: number;
+    };
+    /** ConvoyTracker configuration */
+    convoyTracker?: {
+        /** Auto-update progress on issue changes */
+        autoUpdateProgress?: boolean;
+        /** Progress update interval in ms */
+        progressUpdateInterval?: number;
+        /** Enable persistent storage */
+        persistConvoys?: boolean;
+        /** Storage path for convoy data */
+        storagePath?: string;
+    };
+    /** ConvoyObserver configuration */
+    convoyObserver?: {
+        /** Polling interval in ms */
+        pollInterval?: number;
+        /** Maximum poll attempts (0 = unlimited) */
+        maxPollAttempts?: number;
+        /** Enable WASM for graph analysis */
+        useWasm?: boolean;
+    };
+    /** WASM configuration */
+    wasm?: {
+        /** Enable WASM acceleration */
+        enabled?: boolean;
+        /** Preload WASM modules on init */
+        preload?: boolean;
+    };
+    /** GUPP (Git Universal Pull/Push) adapter configuration */
+    gupp?: {
+        /** Enable GUPP adapter */
+        enabled?: boolean;
+        /** GUPP endpoint URL */
+        endpoint?: string;
+        /** Authentication token */
+        authToken?: string;
+    };
+    /** Logger configuration */
+    logger?: {
+        /** Log level */
+        level?: 'debug' | 'info' | 'warn' | 'error';
+        /** Enable structured logging */
+        structured?: boolean;
+    };
+}
+/**
+ * GUPP (Git Universal Pull/Push) Adapter
+ *
+ * Provides integration with external Git services for cross-repository
+ * bead synchronization. This is a stub implementation - full implementation
+ * would connect to GUPP services.
+ */
+interface IGuppAdapter {
+    /** Check if GUPP is available */
+    isAvailable(): boolean;
+    /** Pull beads from remote */
+    pull(options?: {
+        rig?: string;
+        since?: Date;
+    }): Promise<Bead[]>;
+    /** Push beads to remote */
+    push(beads: Bead[]): Promise<{
+        pushed: number;
+        errors: string[];
+    }>;
+    /** Sync with remote */
+    sync(): Promise<{
+        pulled: number;
+        pushed: number;
+        conflicts: string[];
+    }>;
+}
+/**
+ * Gas Town Bridge Plugin for Claude Flow V3
+ *
+ * Provides integration with Gas Town orchestrator:
+ * - 5 Beads MCP tools (CLI-based)
+ * - 3 Convoy MCP tools
+ * - 4 Formula MCP tools (WASM-accelerated)
+ * - 5 WASM computation tools
+ * - 3 Orchestration tools
+ */
+declare class GasTownBridgePlugin extends EventEmitter implements IPlugin {
+    readonly name = "@claude-flow/plugin-gastown-bridge";
+    readonly version = "0.1.0";
+    readonly description = "Gas Town orchestrator integration with WASM-accelerated formula parsing and graph analysis";
+    private config;
+    private pluginContext;
+    private logger;
+    private gtBridge;
+    private bdBridge;
+    private syncBridge;
+    private formulaExecutor;
+    private convoyTracker;
+    private convoyObserver;
+    private wasmLoader;
+    private guppAdapter;
+    private wasmInitialized;
+    private cliAvailable;
+    private initialized;
+    constructor(config?: Partial<GasTownBridgeConfig>);
+    /**
+     * Register the plugin with claude-flow
+     */
+    register(context: PluginContext): Promise<void>;
+    /**
+     * Initialize the plugin (load WASM, set up bridges)
+     */
+    initialize(context: PluginContext): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Shutdown the plugin (cleanup resources)
+     */
+    shutdown(_context: PluginContext): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get plugin capabilities
+     */
+    getCapabilities(): string[];
+    /**
+     * Get plugin MCP tools
+     */
+    getMCPTools(): PluginMCPTool[];
+    /**
+     * Get plugin hooks
+     */
+    getHooks(): PluginHook[];
+    /**
+     * Get the current configuration
+     */
+    getConfig(): GasTownBridgeConfig;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<GasTownBridgeConfig>): void;
+    /**
+     * Check if WASM is initialized
+     */
+    isWasmReady(): boolean;
+    /**
+     * Check if CLI tools are available
+     */
+    isCliAvailable(): boolean;
+    /**
+     * Get bridge instances
+     */
+    getBridges(): {
+        gt: GtBridge | null;
+        bd: BdBridge | null;
+        sync: SyncBridge | null;
+    };
+    /**
+     * Get formula executor
+     */
+    getFormulaExecutor(): FormulaExecutor | null;
+    /**
+     * Get convoy tracker
+     */
+    getConvoyTracker(): ConvoyTracker | null;
+    /**
+     * Get convoy observer
+     */
+    getConvoyObserver(): ConvoyObserver | null;
+    /**
+     * Get GUPP adapter
+     */
+    getGuppAdapter(): IGuppAdapter | null;
+    /**
+     * Get plugin metadata
+     */
+    getMetadata(): {
+        name: string;
+        version: string;
+        description: string;
+        author: string;
+        license: string;
+        repository: string;
+        keywords: string[];
+        mcpTools: string[];
+        capabilities: string[];
+    };
+    private mergeConfig;
+    private initializeWasm;
+    private checkCliAvailable;
+    private initializeBridges;
+    private initializeFormulaExecutor;
+    private initializeConvoyComponents;
+    private initializeGuppAdapter;
+    /**
+     * Create a stub AgentDB service for SyncBridge initialization.
+     * This stub stores data in-memory and should be replaced with
+     * the real AgentDB service from the plugin context.
+     */
+    private createStubAgentDB;
+    private convertMcpTool;
+    private zodToJsonSchema;
+    private createToolContext;
+    /**
+     * Create the bridge facade for MCP tools.
+     *
+     * NOTE: This facade bridges between the plugin's internal types (from bd-bridge, etc.)
+     * and the external interface types (from types.ts). Type casts are necessary because
+     * the underlying bridges use different type definitions. A future refactor should
+     * unify these type systems.
+     */
+    private createBridgeFacade;
+    private createSyncFacade;
+    private createFormulaWasmFacade;
+    private createDependencyWasmFacade;
+    private simpleSimilarity;
+    private createPreTaskHook;
+    private createPostTaskHook;
+    private createBeadsSyncHook;
+    private createConvoyProgressHook;
+}
+/**
+ * Create a new Gas Town Bridge Plugin instance
+ */
+declare function createGasTownBridgePlugin(config?: Partial<GasTownBridgeConfig>): GasTownBridgePlugin;
+
+export { type AgentRole, type AllocatableType, Arena, type ArenaConfig, ArenaManager, type ArenaStats, type Aspect, AspectSchema, BEAD_ID_PATTERN, BdBridge, type Bead, type BeadDependency, type BeadGraph, BeadIdSchema as BeadIdValidationSchema, BeadSchema, type BeadStatus, BeadStatusSchema, BeadsError, type BlockerInfo, CLIExecutionError, CONVOY_HASH_PATTERN, type CompletionCallback, type CompletionCheckResult, type Convoy, type ConvoyAction, ConvoyError, type ConvoyEvent, type ConvoyEventType, ConvoyIdSchema, type ConvoyLogger, ConvoyObserver, type ConvoyObserverConfig, type ConvoyOptimization, type ConvoyProgress, ConvoyProgressSchema, ConvoySchema, type ConvoyStatus, ConvoyStatusSchema, type ConvoyStrategy, ConvoyTracker, type ConvoyTrackerConfig, type CookedFormula, type CreateBeadOptions, CreateBeadOptionsSchema$1 as CreateBeadOptionsSchema, type CreateConvoyOptions, CreateConvoyOptionsSchema$1 as CreateConvoyOptionsSchema, type CriticalPathResult, type CycleDetectionResult, DEFAULT_CONFIG, type DepAction, type DependencyAction, type DependencyResolution, GasTownErrorCode as ErrorCodes, type ExecuteOptions, type ExecutionProgress, type ExecutorEvents, FORMULA_NAME_PATTERN, type Formula, type FormulaAST, FormulaError, FormulaExecutor, FormulaNameSchema, FormulaSchema, type FormulaType, FormulaTypeSchema, type GasTownAgent, type GasTownAgentRole, GasTownAgentRoleSchema, type GasTownBridgeConfig, GasTownBridgePlugin, type GasTownConfig, GasTownConfigSchema, GasTownError, type GasTownErrorCode$1 as GasTownErrorCode, type GasTownErrorCodeType, GasTownErrorCodes, type GasTownMail, type GraphEdge, GtArgsSchema, GtBridge, type HookPriority, type IBeadsSyncService, type IDependencyWasm, type IFormulaEngine, type IFormulaWasm, type IGasTownBridge, type IGuppAdapter, type IPlugin, type ISyncService, type IWasmBridge, type IWasmLoader, LabelsSchema, Lazy, LazyBridge, LazyModule, LazyObserver, type LazyOptions, type LazyState, type LazyStats, LazyWasm, type Leg, LegSchema, MAX_LENGTHS, MAX_OUTPUT_SIZE, type MCPTool, type MCPToolResult, type MailAction, type MemoryBudget, MemoryBudgetManager, MemoryMonitor, type MemoryMonitorConfig, type MemoryMonitorEvents, type MemoryPressureCallback, type MemoryPressureLevel, type MemoryStats, type MemorySystemConfig, type MemorySystemState, type Molecule, type NodeWeight, ObjectPool, type ObserverLogger, PATH_TRAVERSAL_PATTERNS, type PatternMatch, type PerformanceTiming, type PluginContext, type PluginHook, type PluginMCPTool, type PoolConfig, type PoolStats, type PoolType, type Poolable, PooledBead, PooledConvoy, PooledFormula, PooledMolecule, PooledStep, PrioritySchema, REDACTED_FIELDS, type ReadyIssueInfo, RigNameSchema, SENSITIVE_FIELD_PATTERNS, SHELL_METACHARACTERS, type SlingOptions, SlingOptionsSchema$1 as SlingOptionsSchema, type SlingTarget, SlingTargetSchema, type Step, type StepContext, type StepResult, StepSchema, SyncBridge, type SyncDirection, SyncDirectionSchema, type SyncResult, type Synthesis, SynthesisSchema, type TargetAgent, type Template, TemplateSchema, type ToolContext, type TopoSortResult, type TypeMap, UUID_PATTERN, type ValidationConstraint, ValidationError, SafeStringSchema as ValidatorSafeStringSchema, type Var, VarSchema, type WasmGraphModule, _default as WasmLoader, type WatchHandle, acquireBead, acquireConvoy, acquireFormula, acquireMolecule, acquireStep, arenaManager, beadPool, clearAllPools, clearPerformanceLog, containsPathTraversal, containsShellMetacharacters, convoyPool, cookBatch, cookFormula, createConvoyObserver, createConvoyTracker, createFormulaExecutor, createGasTownBridgePlugin, createLazyConvoyObserver, createLazyProperty, criticalPath, GasTownBridgePlugin as default, detectCycles, disposeAllLazySingletons, disposeDefaultMonitor, disposeLazySingleton, formulaPool, gasTownBridgeTools, getAllPoolStats, getDefaultMonitor, getErrorMessage, getLazyObserverStats, getLazySingleton, getMemoryMonitor, getMemoryReport, getMemoryUsage, getPerformanceLog, getPoolEfficiencySummary, getSystemMemoryStats, getTool, getToolsByLayer, getTotalMemorySaved, getWasmVersions, initializeMemorySystem, isBeadsError, isCLIExecutionError, isGasTownError, isMemorySystemInitialized, isSafeArgument, isValidBeadId, isValidConvoyId, isValidFormulaName, isValidationError, isWasmAvailable, loadFormulaWasm, loadGnnWasm, memoryBudget, moleculePool, onMemoryPressure, parseDate, parseFormula, preWarmAllPools, preloadWasmModules, redactSensitiveFields, releaseBead, releaseConvoy, releaseFormula, releaseMolecule, releaseStep, resetWasmCache, sanitizeBeadOutput, sanitizeBeadsListOutput, sanitizeConvoyOutput, sanitizeFormulaOutput, sanitizeMetadata, sanitizePath, sanitizeString, scopedArena, setMemoryLimit, shutdownMemorySystem, stepPool, toolCategories, toolHandlers, topoSort, triggerMemoryCleanup, validateBead, validateBeadId, validateCreateBeadOptions as validateBeadOptions, validateConfig, validateConvoy, validateConvoyId, validateCreateConvoyOptions as validateConvoyOptions, validateCreateBeadOptions$1 as validateCreateBeadOptions, validateCreateConvoyOptions$1 as validateCreateConvoyOptions, validateFormula, validateFormulaName, validateGtArgs, validateSlingOptions as validateSling, validateSlingOptions$1 as validateSlingOptions, withArena, withArenaSync, wrapError };