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

package/dist/types-CMoOZXrm.d.cts

@@ -0,0 +1,1146 @@
+import { z } from 'zod';
+
+/**
+ * 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 = (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: 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: 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: 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(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(input: unknown): CreateConvoyOptions;
+/**
+ * Validate sling options
+ */
+declare function validateSlingOptions(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 {
+    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>;
+}
+
+export { SlingOptionsSchema as $, type AgentRole as A, type Bead as B, type Convoy as C, CreateConvoyOptionsSchema as D, DEFAULT_CONFIG as E, type Formula as F, type GasTownConfig as G, type DepAction as H, type IGasTownBridge as I, type DependencyAction as J, type DependencyResolution as K, type FormulaAST as L, FormulaSchema as M, FormulaTypeSchema as N, type GasTownAgent as O, type GasTownAgentRole as P, GasTownAgentRoleSchema as Q, GasTownConfigSchema as R, type Step as S, type TopoSortResult as T, type GasTownErrorCode as U, GasTownErrorCodes as V, type GasTownMail as W, type Leg as X, LegSchema as Y, type MailAction as Z, type PatternMatch as _, type BeadStatus as a, type SlingTarget as a0, SlingTargetSchema as a1, StepSchema as a2, type SyncDirection as a3, SyncDirectionSchema as a4, type Synthesis as a5, SynthesisSchema as a6, type TargetAgent as a7, type Template as a8, TemplateSchema as a9, type Var as aa, VarSchema as ab, validateBead as ac, validateConfig as ad, validateConvoy as ae, validateCreateBeadOptions as af, validateCreateConvoyOptions as ag, validateFormula as ah, validateSlingOptions as ai, type FormulaType as b, type ConvoyStatus as c, type IBeadsSyncService as d, type IFormulaWasm as e, type IDependencyWasm as f, type CriticalPathResult as g, type CreateBeadOptions as h, type SlingOptions as i, type SyncResult as j, type BeadGraph as k, type Aspect as l, AspectSchema as m, type BeadDependency as n, BeadSchema as o, BeadStatusSchema as p, type ConvoyAction as q, type ConvoyOptimization as r, type ConvoyProgress as s, ConvoyProgressSchema as t, ConvoySchema as u, ConvoyStatusSchema as v, type ConvoyStrategy as w, type CookedFormula as x, CreateBeadOptionsSchema as y, type CreateConvoyOptions as z };