@claude-flow/plugin-gastown-bridge 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -1,1687 +1,19 @@
 import { EventEmitter } from 'events';
+import { B as Bead, a as BeadStatus, S as Step, F as Formula, b as FormulaType, C as Convoy, c as ConvoyStatus, I as IGasTownBridge$1, d as IBeadsSyncService, e as IFormulaWasm, f as IDependencyWasm, T as TopoSortResult, g as CriticalPathResult, G as GasTownConfig, h as CreateBeadOptions, i as SlingOptions, j as SyncResult, k as BeadGraph } from './types-CMoOZXrm.js';
+export { A as AgentRole, l as Aspect, m as AspectSchema, n as BeadDependency, o as BeadSchema, p as BeadStatusSchema, q as ConvoyAction, r as ConvoyOptimization, s as ConvoyProgress, t as ConvoyProgressSchema, u as ConvoySchema, v as ConvoyStatusSchema, w as ConvoyStrategy, x as CookedFormula, y as CreateBeadOptionsSchema, z as CreateConvoyOptions, D as CreateConvoyOptionsSchema, E as DEFAULT_CONFIG, H as DepAction, J as DependencyAction, K as DependencyResolution, L as FormulaAST, M as FormulaSchema, N as FormulaTypeSchema, O as GasTownAgent, P as GasTownAgentRole, Q as GasTownAgentRoleSchema, R as GasTownConfigSchema, U as GasTownErrorCode, V as GasTownErrorCodes, W as GasTownMail, X as Leg, Y as LegSchema, Z as MailAction, _ as PatternMatch, $ as SlingOptionsSchema, a0 as SlingTarget, a1 as SlingTargetSchema, a2 as StepSchema, a3 as SyncDirection, a4 as SyncDirectionSchema, a5 as Synthesis, a6 as SynthesisSchema, a7 as TargetAgent, a8 as Template, a9 as TemplateSchema, aa as Var, ab as VarSchema, ac as validateBead, ad as validateConfig, ae as validateConvoy, af as validateCreateBeadOptions, ag as validateCreateConvoyOptions, ah as validateFormula, ai as validateSlingOptions } from './types-CMoOZXrm.js';
+import { G as GtBridge } from './gt-bridge-B7hZz5vC.js';
+export { A as AddressSchema, a as GasEstimate, b as GasLimitSchema, c as GasPriceSchema, d as GtArgumentSchema, e as GtBridgeConfig, f as GtBridgeError, g as GtErrorCode, I as GtIdentifierSchema, h as GtLogger, i as GtResult, S as GtSafeStringSchema, N as NetworkSchema, j as NetworkStatus, T as TxHashSchema, k as TxStatus, l as createGtBridge } from './gt-bridge-B7hZz5vC.js';
+import { B as BdBridge } from './bd-bridge-C9wTbkhi.js';
+export { a as BdArgumentSchema, b as BdBridgeConfig, c as BdBridgeError, d as BdErrorCode, e as BdLogger, f as BdResult, g as BdStreamResult, h as BeadIdSchema, i as BeadQuery, j as CliBead, k as CliBeadSchema, l as CliBeadType, m as CliBeadTypeSchema, C as CreateBeadParams, n as createBdBridge } from './bd-bridge-C9wTbkhi.js';
+import { SyncBridge } from './bridges.js';
+export { AgentDBEntry, AgentDBEntrySchema, CliSyncDirection, CliSyncDirectionSchema, CliSyncResult, ConflictStrategy, ConflictStrategySchema, IAgentDBService, SyncBridgeConfig, SyncBridgeError, SyncConflict, SyncErrorCode, SyncLogger, SyncState, SyncStatus, SyncStatusSchema, createSyncBridge } from './bridges.js';
+import { Molecule, FormulaExecutor } from './formula.js';
+export { ExecuteOptions, ExecutionProgress, ExecutorEvents, IWasmLoader, StepContext, StepResult, createFormulaExecutor } from './formula.js';
+import { L as LazyStats, C as ConvoyTracker, a as ConvoyObserver } from './index-BzkAx4ho.js';
+export { B as BlockerInfo, b as CompletionCallback, c as CompletionCheckResult, d as ConvoyEvent, e as ConvoyEventType, f as ConvoyLogger, g as ConvoyObserverConfig, h as ConvoyTrackerConfig, i as Lazy, j as LazyBridge, k as LazyModule, l as LazyObserver, m as LazyOptions, n as LazyState, o as LazyWasm, O as ObserverLogger, R as ReadyIssueInfo, W as WasmGraphModule, p as WatchHandle, q as createConvoyObserver, r as createConvoyTracker, s as createLazyConvoyObserver, t as createLazyProperty, u as disposeAllLazySingletons, v as disposeLazySingleton, w as getLazyObserverStats, x as getLazySingleton } from './index-BzkAx4ho.js';
 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, {
-    id: string;
-    title: string;
-    description: string;
-    status: "open" | "in_progress" | "closed";
-    priority: number;
-    labels: string[];
-    createdAt: Date;
-    updatedAt: Date;
-    blocks?: string[] | undefined;
-    parentId?: string | undefined;
-    assignee?: string | undefined;
-    rig?: string | undefined;
-    blockedBy?: string[] | undefined;
-}, {
-    id: string;
-    title: string;
-    description: string;
-    status: "open" | "in_progress" | "closed";
-    priority: number;
-    labels: string[];
-    createdAt: Date;
-    updatedAt: Date;
-    blocks?: string[] | undefined;
-    parentId?: string | undefined;
-    assignee?: string | undefined;
-    rig?: string | undefined;
-    blockedBy?: 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;
-    labels?: string[] | undefined;
-    assignee?: string | undefined;
-    rig?: string | undefined;
-    parent?: string | undefined;
-}, {
-    title: string;
-    description?: string | undefined;
-    priority?: number | undefined;
-    labels?: string[] | undefined;
-    assignee?: 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, {
-    id: string;
-    title: string;
-    description: string;
-    needs?: string[] | undefined;
-    duration?: number | undefined;
-    requires?: string[] | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}, {
-    id: string;
-    title: string;
-    description: string;
-    needs?: string[] | undefined;
-    duration?: number | undefined;
-    requires?: string[] | undefined;
-    metadata?: Record<string, unknown> | 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, {
-    id: string;
-    title: string;
-    description: string;
-    focus: string;
-    agent?: string | undefined;
-    order?: number | undefined;
-}, {
-    id: string;
-    title: string;
-    description: 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: "merge" | "sequential" | "parallel";
-    description?: string | undefined;
-    format?: string | undefined;
-}, {
-    strategy: "merge" | "sequential" | "parallel";
-    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, {
-    type: "before" | "after" | "around";
-    name: string;
-    pointcut: string;
-    advice: string;
-}, {
-    type: "before" | "after" | "around";
-    name: string;
-    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, {
-        id: string;
-        title: string;
-        description: string;
-        focus: string;
-        agent?: string | undefined;
-        order?: number | undefined;
-    }, {
-        id: string;
-        title: string;
-        description: 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: "merge" | "sequential" | "parallel";
-        description?: string | undefined;
-        format?: string | undefined;
-    }, {
-        strategy: "merge" | "sequential" | "parallel";
-        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, {
-        id: string;
-        title: string;
-        description: string;
-        needs?: string[] | undefined;
-        duration?: number | undefined;
-        requires?: string[] | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }, {
-        id: string;
-        title: string;
-        description: string;
-        needs?: string[] | undefined;
-        duration?: number | undefined;
-        requires?: string[] | undefined;
-        metadata?: Record<string, unknown> | 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, {
-        type: "before" | "after" | "around";
-        name: string;
-        pointcut: string;
-        advice: string;
-    }, {
-        type: "before" | "after" | "around";
-        name: string;
-        pointcut: string;
-        advice: string;
-    }>, "many">>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    description: string;
-    type: "convoy" | "workflow" | "expansion" | "aspect";
-    name: string;
-    version: number;
-    metadata?: Record<string, unknown> | undefined;
-    legs?: {
-        id: string;
-        title: string;
-        description: string;
-        focus: string;
-        agent?: string | undefined;
-        order?: number | undefined;
-    }[] | undefined;
-    synthesis?: {
-        strategy: "merge" | "sequential" | "parallel";
-        description?: string | undefined;
-        format?: string | undefined;
-    } | undefined;
-    steps?: {
-        id: string;
-        title: string;
-        description: string;
-        needs?: string[] | undefined;
-        duration?: number | undefined;
-        requires?: string[] | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }[] | undefined;
-    vars?: Record<string, {
-        name: string;
-        description?: string | undefined;
-        default?: string | undefined;
-        required?: boolean | undefined;
-        pattern?: string | undefined;
-        enum?: string[] | undefined;
-    }> | undefined;
-    templates?: {
-        name: string;
-        content: string;
-        outputPath?: string | undefined;
-    }[] | undefined;
-    aspects?: {
-        type: "before" | "after" | "around";
-        name: string;
-        pointcut: string;
-        advice: string;
-    }[] | undefined;
-}, {
-    description: string;
-    type: "convoy" | "workflow" | "expansion" | "aspect";
-    name: string;
-    version: number;
-    metadata?: Record<string, unknown> | undefined;
-    legs?: {
-        id: string;
-        title: string;
-        description: string;
-        focus: string;
-        agent?: string | undefined;
-        order?: number | undefined;
-    }[] | undefined;
-    synthesis?: {
-        strategy: "merge" | "sequential" | "parallel";
-        description?: string | undefined;
-        format?: string | undefined;
-    } | undefined;
-    steps?: {
-        id: string;
-        title: string;
-        description: string;
-        needs?: string[] | undefined;
-        duration?: number | undefined;
-        requires?: string[] | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }[] | undefined;
-    vars?: Record<string, {
-        name: string;
-        description?: string | undefined;
-        default?: string | undefined;
-        required?: boolean | undefined;
-        pattern?: string | undefined;
-        enum?: string[] | undefined;
-    }> | undefined;
-    templates?: {
-        name: string;
-        content: string;
-        outputPath?: string | undefined;
-    }[] | undefined;
-    aspects?: {
-        type: "before" | "after" | "around";
-        name: string;
-        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, {
-    id: string;
-    status: "active" | "landed" | "failed" | "paused";
-    name: string;
-    trackedIssues: string[];
-    startedAt: Date;
-    progress: {
-        closed: number;
-        total: number;
-        inProgress: number;
-        blocked: number;
-    };
-    description?: string | undefined;
-    completedAt?: Date | undefined;
-    formula?: string | undefined;
-}, {
-    id: string;
-    status: "active" | "landed" | "failed" | "paused";
-    name: string;
-    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, {
-    issues: string[];
-    name: string;
-    description?: string | undefined;
-    formula?: string | undefined;
-}, {
-    issues: string[];
-    name: 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, {
-    townRoot: string;
-    enableBeadsSync: boolean;
-    syncInterval: number;
-    nativeFormulas: boolean;
-    enableConvoys: boolean;
-    autoCreateBeads: boolean;
-    enableGUPP: boolean;
-    guppCheckInterval: number;
-    cliTimeout: number;
-}, {
-    townRoot?: string | undefined;
-    enableBeadsSync?: boolean | undefined;
-    syncInterval?: number | 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
  *
@@ -2426,243 +758,6 @@ declare class MemoryBudgetManager {
  */
 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
  *
@@ -2789,325 +884,6 @@ declare function acquireMolecule(): PooledMolecule;
  */
 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
  *
@@ -4685,4 +2461,4 @@ declare class GasTownBridgePlugin extends EventEmitter implements IPlugin {
  */
 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 };
+export { type AllocatableType, Arena, type ArenaConfig, ArenaManager, type ArenaStats, BEAD_ID_PATTERN, BdBridge, Bead, BeadGraph, BeadIdSchema as BeadIdValidationSchema, BeadStatus, BeadsError, CLIExecutionError, CONVOY_HASH_PATTERN, Convoy, ConvoyError, ConvoyIdSchema, ConvoyObserver, ConvoyStatus, ConvoyTracker, CreateBeadOptions, CriticalPathResult, type CycleDetectionResult, GasTownErrorCode as ErrorCodes, FORMULA_NAME_PATTERN, Formula, FormulaError, FormulaExecutor, FormulaNameSchema, FormulaType, type GasTownBridgeConfig, GasTownBridgePlugin, GasTownConfig, GasTownError, type GasTownErrorCodeType, type GraphEdge, GtArgsSchema, GtBridge, type HookPriority, IBeadsSyncService, IDependencyWasm, type IFormulaEngine, IFormulaWasm, type IGasTownBridge, type IGuppAdapter, type IPlugin, type ISyncService, type IWasmBridge, LabelsSchema, LazyStats, MAX_LENGTHS, MAX_OUTPUT_SIZE, type MCPTool, type MCPToolResult, type MemoryBudget, MemoryBudgetManager, MemoryMonitor, type MemoryMonitorConfig, type MemoryMonitorEvents, type MemoryPressureCallback, type MemoryPressureLevel, type MemoryStats, type MemorySystemConfig, type MemorySystemState, Molecule, type NodeWeight, ObjectPool, PATH_TRAVERSAL_PATTERNS, type PerformanceTiming, type PluginContext, type PluginHook, type PluginMCPTool, type PoolConfig, type PoolStats, type PoolType, type Poolable, PooledBead, PooledConvoy, PooledFormula, PooledMolecule, PooledStep, PrioritySchema, REDACTED_FIELDS, RigNameSchema, SENSITIVE_FIELD_PATTERNS, SHELL_METACHARACTERS, SlingOptions, Step, SyncBridge, SyncResult, type ToolContext, TopoSortResult, type TypeMap, UUID_PATTERN, type ValidationConstraint, ValidationError, SafeStringSchema as ValidatorSafeStringSchema, _default as WasmLoader, acquireBead, acquireConvoy, acquireFormula, acquireMolecule, acquireStep, arenaManager, beadPool, clearAllPools, clearPerformanceLog, containsPathTraversal, containsShellMetacharacters, convoyPool, cookBatch, cookFormula, createGasTownBridgePlugin, criticalPath, GasTownBridgePlugin as default, detectCycles, disposeDefaultMonitor, formulaPool, gasTownBridgeTools, getAllPoolStats, getDefaultMonitor, getErrorMessage, 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, validateBeadId, validateCreateBeadOptions as validateBeadOptions, validateConvoyId, validateCreateConvoyOptions as validateConvoyOptions, validateFormulaName, validateGtArgs, validateSlingOptions as validateSling, withArena, withArenaSync, wrapError };