┌─────────────────────────────────────────────────────────────────────┐
│                      Claude Flow V3 Plugin Host                      │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌─────────────────────┐    ┌─────────────────────────────────────┐ │
│  │    CLI Bridge       │    │         WASM Computation Layer       │ │
│  │  (I/O Operations)   │    │           (352x faster)              │ │
│  │                     │    │                                      │ │
│  │  • gt commands      │    │  ┌──────────────┐ ┌──────────────┐  │ │
│  │  • bd commands      │    │  │ gastown-     │ │ ruvector-    │  │ │
│  │  • File read/write  │    │  │ formula-wasm │ │ gnn-wasm     │  │ │
│  │  • SQLite queries   │    │  │              │ │              │  │ │
│  │                     │    │  │ • TOML parse │ │ • DAG ops    │  │ │
│  │  [Node.js FFI]      │    │  │ • Variable   │ │ • Topo sort  │  │ │
│  │                     │    │  │   cooking    │ │ • Cycle      │  │ │
│  └─────────┬───────────┘    │  │ • Molecule   │ │   detection  │  │ │
│            │                │  │   generation │ │ • Critical   │  │ │
│            │                │  └──────────────┘ │   path       │  │ │
│            │                │                   └──────────────┘  │ │
│            │                │                                      │ │
│            │                │  ┌──────────────┐ ┌──────────────┐  │ │
│            │                │  │ micro-hnsw-  │ │ ruvector-    │  │ │
│            │                │  │ wasm         │ │ learning-wasm│  │ │
│            │                │  │              │ │              │  │ │
│            │                │  │ • Pattern    │ │ • SONA       │  │ │
│            │                │  │   search     │ │   patterns   │  │ │
│            │                │  │ • 150x-12500x│ │ • MoE routing│  │ │
│            │                │  │   speedup    │ │ • EWC++      │  │ │
│            │                │  └──────────────┘ └──────────────┘  │ │
│            │                │                                      │ │
│            │                │  [wasm-bindgen interface]            │ │
│            │                └─────────────────────────────────────┘ │
│            │                              │                         │
│            └──────────────┬───────────────┘                         │
│                           │                                         │
│                           ▼                                         │
│  ┌─────────────────────────────────────────────────────────────────┐│
│  │                     MCP Tool Interface                          ││
│  │                     (15 Tools + 5 WASM)                         ││
│  └─────────────────────────────────────────────────────────────────┘│
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

{
  "name": "@claude-flow/plugin-gastown-bridge",
  "version": "0.1.0",
  "description": "Gas Town orchestrator integration for Claude Flow V3",
  "keywords": ["gastown", "beads", "orchestration", "workflows", "formulas"]
}

// Bead types (matching Gas Town's beads.db schema)
export interface Bead {
  id: string;           // e.g., "gt-abc12"
  title: string;
  description: string;
  status: 'open' | 'in_progress' | 'closed';
  priority: number;     // 0 = highest
  labels: string[];
  parent_id?: string;   // For epics
  created_at: Date;
  updated_at: Date;
  assignee?: string;
  rig?: string;
}

// Convoy types
export interface Convoy {
  id: string;
  name: string;
  tracked_issues: string[];
  status: 'active' | 'landed' | 'failed';
  started_at: Date;
  completed_at?: Date;
  progress: {
    total: number;
    closed: number;
    in_progress: number;
  };
}

// Formula types (matching Gas Town's formula/types.go)
export type FormulaType = 'convoy' | 'workflow' | 'expansion' | 'aspect';

export interface Formula {
  name: string;
  description: string;
  type: FormulaType;
  version: number;

  // Convoy-specific
  legs?: Leg[];
  synthesis?: Synthesis;

  // Workflow-specific
  steps?: Step[];
  vars?: Record<string, Var>;

  // Expansion-specific
  template?: Template[];

  // Aspect-specific
  aspects?: Aspect[];
}

export interface Step {
  id: string;
  title: string;
  description: string;
  needs?: string[];  // Dependencies
}

export interface Leg {
  id: string;
  title: string;
  focus: string;
  description: string;
}

import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

export class GasTownBridge {
  private townRoot: string;

  constructor(townRoot: string = '~/gt') {
    this.townRoot = townRoot;
  }

  // Execute gt command
  async gt(args: string[]): Promise<string> {
    const { stdout } = await execAsync(
      `gt ${args.join(' ')}`,
      { cwd: this.townRoot }
    );
    return stdout;
  }

  // Execute bd command
  async bd(args: string[]): Promise<string> {
    const { stdout } = await execAsync(
      `bd ${args.join(' ')} --json`,
      { cwd: this.townRoot }
    );
    return stdout;
  }

  // Create a bead
  async createBead(opts: CreateBeadOptions): Promise<Bead> {
    const args = ['create', `"${opts.title}"`];
    if (opts.priority !== undefined) args.push('-p', opts.priority.toString());
    if (opts.labels?.length) args.push('-l', opts.labels.join(','));
    if (opts.parent) args.push('--parent', opts.parent);

    const result = await this.bd(args);
    return JSON.parse(result);
  }

  // Get ready beads
  async getReady(limit = 10): Promise<Bead[]> {
    const result = await this.bd(['ready', '--limit', limit.toString()]);
    return JSON.parse(result);
  }

  // Sling work to agent
  async sling(beadId: string, target: string, formula?: string): Promise<void> {
    const args = ['sling', beadId, target];
    if (formula) args.push('--formula', formula);
    await this.gt(args);
  }
}

import { AgentDB } from '@claude-flow/agentdb';

export class BeadsSyncService {
  private bridge: GasTownBridge;
  private agentdb: AgentDB;

  constructor(bridge: GasTownBridge, agentdb: AgentDB) {
    this.bridge = bridge;
    this.agentdb = agentdb;
  }

  // Sync beads to AgentDB namespace
  async pullBeads(rig?: string): Promise<number> {
    const beads = await this.bridge.bd(['list', '--json', rig ? `--rig=${rig}` : '']);
    const parsed: Bead[] = JSON.parse(beads);

    let synced = 0;
    for (const bead of parsed) {
      await this.agentdb.memory.store({
        namespace: 'gastown:beads',
        key: bead.id,
        value: JSON.stringify(bead),
        metadata: {
          source: 'gastown',
          rig: bead.rig || 'town',
          status: bead.status,
          priority: bead.priority,
        }
      });
      synced++;
    }

    return synced;
  }

  // Push AgentDB tasks to Beads
  async pushTasks(namespace: string): Promise<number> {
    const tasks = await this.agentdb.memory.list({ namespace });

    let pushed = 0;
    for (const task of tasks.entries) {
      // Check if already exists in Beads
      const existing = await this.bridge.bd(['show', task.key, '--json']).catch(() => null);
      if (!existing) {
        const parsed = JSON.parse(task.value);
        await this.bridge.createBead({
          title: parsed.title || task.key,
          description: parsed.description || '',
          priority: parsed.priority || 2,
          labels: ['from-claude-flow'],
        });
        pushed++;
      }
    }

    return pushed;
  }
}

import * as TOML from '@iarna/toml';

export class FormulaParser {
  // Parse formula.toml content
  parse(content: string): Formula {
    const parsed = TOML.parse(content) as any;

    return {
      name: parsed.formula,
      description: parsed.description,
      type: parsed.type as FormulaType,
      version: parsed.version || 1,
      legs: parsed.legs,
      synthesis: parsed.synthesis,
      steps: parsed.steps,
      vars: parsed.vars,
      template: parsed.template,
      aspects: parsed.aspects,
    };
  }

  // Cook formula with variable substitution
  cook(formula: Formula, vars: Record<string, string>): CookedFormula {
    const substitute = (text: string): string => {
      return text.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] || `{{${key}}}`);
    };

    // Deep clone and substitute
    const cooked = JSON.parse(JSON.stringify(formula));

    if (cooked.steps) {
      cooked.steps = cooked.steps.map((step: Step) => ({
        ...step,
        title: substitute(step.title),
        description: substitute(step.description),
      }));
    }

    // ... similar for legs, aspects, etc.

    return {
      ...cooked,
      cookedAt: new Date(),
      vars,
    };
  }

  // Generate molecule (bead chain) from cooked formula
  async toMolecule(cooked: CookedFormula, bridge: GasTownBridge): Promise<string[]> {
    const beadIds: string[] = [];

    if (cooked.type === 'workflow' && cooked.steps) {
      // Create beads for each step
      for (const step of cooked.steps) {
        const bead = await bridge.createBead({
          title: step.title,
          description: step.description,
          labels: ['molecule', cooked.name],
        });
        beadIds.push(bead.id);
      }

      // Wire dependencies
      for (let i = 0; i < cooked.steps.length; i++) {
        const step = cooked.steps[i];
        if (step.needs) {
          for (const dep of step.needs) {
            const depIndex = cooked.steps.findIndex(s => s.id === dep);
            if (depIndex >= 0) {
              await bridge.bd(['dep', 'add', beadIds[i], beadIds[depIndex]]);
            }
          }
        }
      }
    }

    return beadIds;
  }
}

v3/plugins/gastown-bridge/
├── package.json
├── tsconfig.json
├── README.md
├── Cargo.toml                 # Rust workspace for WASM modules
├── src/
│   ├── index.ts               # Main exports + plugin class
│   ├── types.ts               # Zod schemas
│   ├── mcp-tools.ts           # 20 MCP tool definitions
│   ├── wasm-loader.ts         # WASM module loader + caching
│   ├── bridges/
│   │   ├── gt-bridge.ts       # Gas Town CLI bridge
│   │   ├── bd-bridge.ts       # Beads CLI bridge
│   │   └── sync-bridge.ts     # Beads-AgentDB sync
│   ├── formula/
│   │   ├── parser.ts          # JS fallback parser
│   │   ├── cooker.ts          # JS fallback cooker
│   │   └── executor.ts        # Molecule execution (hybrid)
│   └── convoy/
│       ├── tracker.ts         # Convoy lifecycle
│       └── observer.ts        # Convoy completion detection
├── wasm/
│   ├── gastown-formula-wasm/  # TOML parsing + cooking
│   │   ├── Cargo.toml
│   │   ├── src/
│   │   │   ├── lib.rs         # WASM entry point
│   │   │   ├── parser.rs      # TOML → AST
│   │   │   ├── cooker.rs      # Variable substitution
│   │   │   └── molecule.rs    # Molecule generation
│   │   └── pkg/               # wasm-pack output
│   ├── ruvector-gnn-wasm/     # Graph operations
│   │   ├── Cargo.toml
│   │   ├── src/
│   │   │   ├── lib.rs
│   │   │   ├── dag.rs         # DAG operations
│   │   │   ├── topo.rs        # Topological sort
│   │   │   └── critical.rs    # Critical path analysis
│   │   └── pkg/
│   ├── micro-hnsw-wasm/       # Pattern search (shared)
│   │   └── ...                # From @claude-flow/plugin-micro-hnsw
│   └── ruvector-learning-wasm/ # SONA patterns (shared)
│       └── ...                # From @claude-flow/plugin-ruvector-learning
├── tests/
│   ├── bridges.test.ts
│   ├── formula.test.ts
│   ├── wasm.test.ts           # WASM module tests
│   └── mcp-tools.test.ts
└── scripts/
    ├── build-wasm.sh          # wasm-pack build script
    └── benchmark.ts           # WASM vs JS benchmarks

[package]
name = "gastown-formula-wasm"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
wasm-bindgen = "0.2"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
toml = "0.8"
js-sys = "0.3"

[dependencies.web-sys]
version = "0.3"
features = ["console"]

[profile.release]
opt-level = 3
lto = true

export interface GasTownConfig {
  // Path to Gas Town installation
  townRoot: string;

  // Enable Beads sync
  enableBeadsSync: boolean;
  syncInterval: number;  // ms

  // Enable native formula execution (vs. shelling to gt)
  nativeFormulas: boolean;

  // Enable convoy tracking in Claude Flow
  enableConvoys: boolean;

  // Auto-create beads from Claude Flow tasks
  autoCreateBeads: boolean;

  // GUPP integration
  enableGUPP: boolean;
  guppCheckInterval: number;  // ms
}

use wasm_bindgen::prelude::*;
use serde::{Deserialize, Serialize};
use toml;

#[derive(Serialize, Deserialize)]
pub struct Formula {
    pub name: String,
    pub description: String,
    #[serde(rename = "type")]
    pub formula_type: String,
    pub version: Option<u32>,
    pub legs: Option<Vec<Leg>>,
    pub steps: Option<Vec<Step>>,
    pub vars: Option<std::collections::HashMap<String, Var>>,
}

#[derive(Serialize, Deserialize)]
pub struct Step {
    pub id: String,
    pub title: String,
    pub description: String,
    pub needs: Option<Vec<String>>,
}

#[wasm_bindgen]
pub fn parse_formula(content: &str) -> Result<JsValue, JsValue> {
    let formula: Formula = toml::from_str(content)
        .map_err(|e| JsValue::from_str(&format!("Parse error: {}", e)))?;

    serde_wasm_bindgen::to_value(&formula)
        .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))
}

#[wasm_bindgen]
pub fn cook_formula(formula_json: &str, vars_json: &str) -> Result<String, JsValue> {
    let formula: Formula = serde_json::from_str(formula_json)
        .map_err(|e| JsValue::from_str(&format!("Formula parse error: {}", e)))?;

    let vars: std::collections::HashMap<String, String> = serde_json::from_str(vars_json)
        .map_err(|e| JsValue::from_str(&format!("Vars parse error: {}", e)))?;

    // Perform variable substitution
    let cooked = substitute_vars(&formula, &vars);

    serde_json::to_string(&cooked)
        .map_err(|e| JsValue::from_str(&format!("Serialize error: {}", e)))
}

fn substitute_vars(formula: &Formula, vars: &std::collections::HashMap<String, String>) -> Formula {
    let substitute = |text: &str| -> String {
        let mut result = text.to_string();
        for (key, value) in vars {
            result = result.replace(&format!("{{{{{}}}}}", key), value);
        }
        result
    };

    Formula {
        name: formula.name.clone(),
        description: substitute(&formula.description),
        formula_type: formula.formula_type.clone(),
        version: formula.version,
        legs: formula.legs.clone(),
        steps: formula.steps.as_ref().map(|steps| {
            steps.iter().map(|step| Step {
                id: step.id.clone(),
                title: substitute(&step.title),
                description: substitute(&step.description),
                needs: step.needs.clone(),
            }).collect()
        }),
        vars: formula.vars.clone(),
    }
}

import init, { parse_formula, cook_formula } from './wasm/gastown-formula-wasm/pkg';

let wasmInitialized = false;

export class FormulaWasm {
  private static instance: FormulaWasm;

  static async getInstance(): Promise<FormulaWasm> {
    if (!FormulaWasm.instance) {
      FormulaWasm.instance = new FormulaWasm();
      await FormulaWasm.instance.initialize();
    }
    return FormulaWasm.instance;
  }

  private async initialize(): Promise<void> {
    if (!wasmInitialized) {
      await init();
      wasmInitialized = true;
    }
  }

  // 352x faster than JavaScript
  parseFormula(content: string): Formula {
    return parse_formula(content);
  }

  // 352x faster than JavaScript
  cookFormula(formula: Formula, vars: Record<string, string>): CookedFormula {
    const result = cook_formula(
      JSON.stringify(formula),
      JSON.stringify(vars)
    );
    return JSON.parse(result);
  }
}

{
  "dependencies": {
    "@claude-flow/plugin-micro-hnsw": "^0.1.0",
    "@claude-flow/plugin-ruvector-gnn": "^0.1.0",
    "@claude-flow/plugin-ruvector-learning": "^0.1.0"
  },
  "devDependencies": {
    "@aspect-js/bazel-lib": "^1.0.0"
  }
}

[dependencies]
wasm-bindgen = "0.2"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
serde-wasm-bindgen = "0.6"
toml = "0.8"
js-sys = "0.3"
petgraph = "0.6"  # For graph operations

User Request → MCP Tool → Route Decision
                              │
              ┌───────────────┼───────────────┐
              │               │               │
              ▼               ▼               ▼
         CLI Bridge      WASM Layer      Hybrid
         (I/O ops)       (compute)      (both)
              │               │               │
              ▼               ▼               ▼
         gt/bd CLI       WASM module    CLI → WASM
              │               │               │
              └───────────────┴───────────────┘
                              │
                              ▼
                        MCP Response