Enabling AI-Augmented MBSE with MCP

Systems Engineering Capstone: Advisor Review

Andrew Dunn

GitLab, Public Sector

Greg Pappas

Department of Defense, Army DEVCOM

Dr. Stephen Rapp (Advisor)

Wayne State University, ISE

2026-02-15

Thesis & Motivation

Central Thesis

Harness design matters more than model capability for AI-augmented systems engineering.

LLMs alone cannot reliably produce system models. Tooling that provides parsing, validation, and structural feedback transforms LLM output from unusable to useful.

The Problem Isn’t Going Away

• Raw LLM capability is insufficient. SysMBench tested 17 LLMs including frontier models; best BLEU score was 4%, best semantic F1 was 62% [1]
  • Enhancement strategies (few-shot, chain-of-thought) provided only marginal improvement. The failure mode is structural (modeling language syntax), not reasoning
• Context windows are a ceiling, not a floor. Bader et al. exceeded 16K tokens generating ~8 elements in XMI; even 30% pre-processing reduction was insufficient [2]
  • Larger windows don’t help when the format is inherently verbose
• Corpus scarcity can’t be trained away. SysML v2 was adopted July 2025; training data barely exists. SysTemp compensates with templates because LLMs can’t learn from limited examples [3]
• Single-shot generation fails. Ferrari et al. found correctness not significantly above baseline across 28 requirements documents; session memory pollution actively degrades output [4]

The Gap

• 0 MCP servers for SysML among 7,364+ public MCP repositories
• SE project context alone consumes 40K+ tokens, leaving minimal budget for model content
• No standardized AI-MBSE interface; every paper implements custom integration

Why Now

• MCP protocol reached stability (Nov 2024), adopted by major AI providers
• SysML v2 textual notation explicitly recommended as more LLM-friendly than XMI [2]
• 75,000+ GitHub stars on MCP ecosystem repos; momentum is real
• Tree-sitter grammars are straightforward to produce (~25 hours to 99.6% coverage), but OMG’s KEBNF spec doesn’t easily yield one (335+ LR conflicts). A hand-tuned grammar is a meaningful contribution
• No tree-sitter grammar for SysML v2 existed; tree-sitter’s error recovery and incremental parsing make it uniquely suited for AI tooling where ANTLR doesn’t fit

Exploring the Space

• An MCP server with context-aware tools (L0/L1/L2 detail levels, cache IDs, overflow detection) is a research instrument for exploring reduction strategies, not just a product
• Each tool call is a measurable experiment: what context does the LLM actually need to reason about a model?
• Positions capstone as infrastructure for continued research (directed study → INCOSE 2027 benchmark)

SysML v2: From Documentation to Computation

What is MBSE?

Model-Based Systems Engineering means expressing system designs as structured, machine-readable models rather than documents. SysML is the OMG standard language for this: system architects use it to define parts, requirements, behaviors, and constraints for complex systems in defense, aerospace, automotive, and medical domains.

Why Do People Want LLMs in MBSE?

MBSE has a persistent model-reality gap: system architectures that can’t be validated, simulated, or traced to requirements without extensive manual effort and custom tooling. Engineers spend more time maintaining models than reasoning about designs.

LLMs promise to bridge this by reading, generating, and modifying models directly. But they need the right input format, and they need structured tooling to compensate for their limitations (4% BLEU on system model generation even with frontier models [1]).

The v1 → v2 Revolution

SysML v1 was graphical-only, UML-based, with ambiguous semantics. XMI interchange failed because “every tool exports XMI differently.” v2 (adopted July 2025 by OMG, 80+ organizations, 7 years of development) is a fundamentally different language built on KerML formal logic:

part def Vehicle {
    attribute mass :> ISQBase::mass;
    part engine : Engine {
        attribute mass :> ISQBase::mass = 200 [kg];
    }
    attribute totalMass :> ISQBase::mass =
        engine.mass + transmission.mass;
}

Requirements become evaluable constraints that return true/false, enabling automated verification directly from models.

Why This Changes Everything for AI

Property	SysML v2	SysML v1 / XMI
Format	Textual, human-readable	Graphical / XML serialization
Diffable	Yes (Git-native)	No (binary diagrams, verbose XML)
Semantics	KerML formal logic	UML profile, ambiguous
Constraints	Built-in expression language	OCL (software-oriented)
Token cost	Compact (~50 tokens/element)	Verbose (~500+ tokens/element)
Paradigm	Computation	Documentation

The XMI Problem

Bader et al. found XMI serialization consumed 16K+ tokens for just ~8 model elements [2]. Even 30% pre-processing reduction was insufficient. Compare the same element in both formats:

<packagedElement xmi:type="uml:Component"
  xmi:id="_abc123" name="Vehicle"
  visibility="public">
  <ownedAttribute xmi:type="uml:Property"
    xmi:id="_def456" name="mass" .../>
</packagedElement>

vs. part def Vehicle { attribute mass :> ISQBase::mass; } in SysML v2.

Why Now

SysML v2’s textual notation makes LLM+MBSE tractable for the first time. Models can be stored in Git, parsed by tree-sitter, processed through CI/CD pipelines, and accessed by AI agents via MCP. This is the exact workflow this capstone demonstrates.

Literature Positioning

The Harness Matters More Than the Model

Our central thesis: harness design matters more than model capability for AI-augmented systems engineering. The literature provides strong quantitative evidence.

SysMBench [1] tested 17 LLMs including frontier models on system model generation. Best BLEU score: 4%. Best semantic F1: 62%. Enhancement strategies (few-shot, chain-of-thought) provided only marginal improvement. The failure mode is structural, not reasoning. When the best available LLMs achieve 4% on system models, external tooling is not optional but essential.

The literature reveals five context management strategies (avoidance, staged decomposition, template-mediated structuring, progressive narrowing, multi-agent partitioning) but each paper implements custom integration. No standardized interface exists.

The Sweet Spot

Exploring the intersection of SysML v2 specificity and structured MCP tooling is a meaningful research contribution. The scatter plot (right) shows 10 papers across two dimensions. No existing work occupies the top-right quadrant. SysTemp comes closest (template-mediated SysML v2) but uses custom integration, not a reusable protocol. 0 MCP servers for SysML among 7,364+ public MCP repositories.

Infrastructure with Independent Value

The artifacts built for this exploration have standalone utility regardless of thesis outcome:

• tree-sitter-sysml: First SysML v2 grammar for tree-sitter. MIT licensed, 6 language bindings. Usable for syntax highlighting, code navigation, and IDE support independent of any LLM integration
• kebnf-to-tree-sitter: First automated KEBNF-to-tree-sitter converter. Applicable to any OMG specification grammar, not just SysML
• open-mcp-sysml: Reusable MCP server pattern for any Git-hosted modeling language. Provider-agnostic design (GitLab as reference implementation)

litData = [
  {key: "SysMBench", author: "Jin et al.", x: 0.85, y: 0.15, color: "#E45756"},
  {key: "SysTemp", author: "Bouamra et al.", x: 0.80, y: 0.70, color: "#F58518"},
  {key: "Li", author: "Li et al.", x: 0.75, y: 0.50, color: "#F58518"},
  {key: "Bader", author: "Bader et al.", x: 0.55, y: 0.45, color: "#72B7B2"},
  {key: "Darm", author: "Darm et al.", x: 0.50, y: 0.75, color: "#72B7B2"},
  {key: "NOMAD", author: "Giannouris", x: 0.20, y: 0.80, color: "#4C78A8"},
  {key: "Erikstad", author: "Erikstad", x: 0.25, y: 0.65, color: "#4C78A8"},
  {key: "Ferrari", author: "Ferrari et al.", x: 0.15, y: 0.15, color: "#B279A2"},
  {key: "Rouabhia", author: "Rouabhia", x: 0.20, y: 0.10, color: "#B279A2"},
  {key: "Otten", author: "Otten et al.", x: 0.15, y: 0.45, color: "#B279A2"},
  {key: "Hendricks", author: "Hendricks", x: 0.40, y: 0.20, color: "#72B7B2"}
]

// Literature Positioning Scatter Plot (litScatter)
// --------------------------------------------------
// Pattern: 2D scatter plot with quadrant highlighting.
//
// Layout strategy:
//   - X axis = SysML Specificity (0→1), Y axis = Tooling Integration (0→1)
//   - Each paper is a colored circle at (x, y) with a text label offset to the right
//   - A green highlighted rectangle marks "THE GAP" (top-right quadrant, x>0.6, y>0.6)
//     where no existing work sits — this is where our project lives
//   - "This Project" is a larger, stroked green circle at (0.95, 0.95)
//   - Paper colors encode category: red=benchmark, orange=SysML-specific,
//     teal=tooling, blue=general AI, purple=requirements
//
// Axis labels use custom tick formatters mapping 0→1 to semantic labels
// (General→SysML v2, None→Structured) with only the endpoints and midpoint labeled.
//
// To add a paper: append to litData array with {key, author, x, y, color}.
litScatter = {
  const w = 1100, h = 900;
  const m = {top: 60, right: 170, bottom: 75, left: 110};
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, w, h])
    .attr("width", w).attr("height", h)
    .style("font-family", "system-ui, sans-serif");

  const xScale = d3.scaleLinear().domain([0, 1]).range([m.left, w - m.right]);
  const yScale = d3.scaleLinear().domain([0, 1]).range([h - m.bottom, m.top]);

  svg.append("rect")
    .attr("x", xScale(0.6)).attr("y", yScale(1))
    .attr("width", xScale(1) - xScale(0.6)).attr("height", yScale(0.6) - yScale(1))
    .attr("fill", "#54A24B").attr("opacity", 0.06);
  svg.append("text")
    .attr("x", xScale(0.8)).attr("y", yScale(0.92))
    .attr("text-anchor", "middle")
    .text("THE GAP").style("font-size", "16px").style("fill", "#54A24B")
    .style("font-weight", "bold").style("opacity", 0.5);

  svg.append("g").attr("transform", `translate(0,${h - m.bottom})`)
    .call(d3.axisBottom(xScale).ticks(5).tickFormat(d => ["General", "", "Mixed", "", "SysML v2"][d * 4] || ""))
    .call(g => g.select(".domain").attr("stroke", "#ccc"))
    .selectAll("text").style("font-size", "13px");
  svg.append("text").attr("x", (m.left + w - m.right) / 2).attr("y", h - 8)
    .attr("text-anchor", "middle").text("SysML Specificity →")
    .style("font-size", "14px").style("fill", "#666");

  svg.append("g").attr("transform", `translate(${m.left},0)`)
    .call(d3.axisLeft(yScale).ticks(5).tickFormat(d => ["None", "", "Partial", "", "Structured"][d * 4] || ""))
    .call(g => g.select(".domain").attr("stroke", "#ccc"))
    .selectAll("text").style("font-size", "13px");
  svg.append("text").attr("x", -(m.top + h - m.bottom) / 2).attr("y", 16)
    .attr("text-anchor", "middle").attr("transform", "rotate(-90)")
    .text("Tooling Integration →")
    .style("font-size", "14px").style("fill", "#666");

  svg.selectAll("circle.paper")
    .data(litData).join("circle")
    .attr("cx", d => xScale(d.x)).attr("cy", d => yScale(d.y))
    .attr("r", 10).attr("fill", d => d.color).attr("opacity", 0.7)
    .attr("stroke", d => d.color).attr("stroke-width", 1.5);

  svg.selectAll("text.label")
    .data(litData).join("text")
    .attr("x", d => xScale(d.x) + 14).attr("y", d => yScale(d.y) + 5)
    .text(d => d.key).style("font-size", "13px").style("fill", "#555");

  svg.append("circle")
    .attr("cx", xScale(0.95)).attr("cy", yScale(0.95))
    .attr("r", 14).attr("fill", "#54A24B").attr("opacity", 0.3)
    .attr("stroke", "#54A24B").attr("stroke-width", 3);
  svg.append("text")
    .attr("x", xScale(0.95)).attr("y", yScale(0.95) - 20)
    .attr("text-anchor", "middle").text("This Project")
    .style("font-size", "14px").style("font-weight", "bold").style("fill", "#54A24B");

  return svg.node();
}

Project Concept & Architecture

What We Built

A Rust MCP server that gives AI assistants structured access to SysML v2 models via the Model Context Protocol.

// Architecture Diagram (archSvg)
// ---------------------------------
// Pattern: Layered box diagram with curved inter-crate edges and an SVG gear icon.
//
// Layout strategy:
//   - 4 horizontal layers (layerY array): client → server boundary → crates → external
//   - Each component is a rounded rect with label/sublabel, positioned by [cx, cy]
//   - A dashed red rect groups the 3 internal crates as "open-mcp-sysml"
//   - Straight lines with arrowhead markers connect vertical layers
//   - crateEdge() draws cubic bezier curves for intra-server dependencies
//     (mcp-server → sysml-parser, mcp-server → repo-client)
//
// Gear icon (epicyclic gearing, adapted from https://observablehq.com/@d3/epicyclic-gearing):
//   - Renders a static gear SVG path using the tooth-by-tooth arc+line algorithm
//   - Parameters: gearTeeth (number of teeth), gearR (pitch radius), toothR (tooth height),
//     holeR (center hole radius)
//   - Each tooth: arc along inner radius → line to pitch → line to outer → arc along outer →
//     line back to pitch → line to inner
//   - Center hole is a second subpath (M...A...A...Z) creating a cutout
//   - Strategy labels are placed radially at (gr1 + 18) from center using cos/sin
//
// Arrowhead marker: refX=5 positions the line endpoint at the BACK of the arrowhead
//   (refX=10 would put it at the tip, causing line overlap). Adjust refX to control
//   where the line "connects" to the arrow.
//
// Sizing: margin-bottom is negative to pull subsequent content up (the SVG has dead
//   space at bottom due to the viewBox being taller than the visual content needs).
archSvg = {
  const w = 1128, h = 875;
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, w, h])
    .attr("width", w).attr("height", h)
    .style("font-family", "system-ui, sans-serif")
    .style("margin-bottom", "-180px");

  const boxH = 100;
  const layerY = [40, 200, 420, 620];
  const pos = {
    client: [w/2, layerY[0]],
    mcp: [w/2 - 240, layerY[2]],
    parser: [w/2, layerY[2]],
    repo: [w/2 + 240, layerY[2]],
    git: [w/2 + 240, layerY[3]]
  };

  svg.append("defs").append("marker").attr("id", "arrowhead")
    .attr("viewBox", "0 0 10 10").attr("refX", 5).attr("refY", 5)
    .attr("markerWidth", 10).attr("markerHeight", 10).attr("orient", "auto")
    .append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("fill", "#999");

  svg.append("rect").attr("x", w/2 - 430).attr("y", layerY[1] - 30)
    .attr("width", 860).attr("height", 370).attr("rx", 14)
    .attr("fill", "none").attr("stroke", "#E45756").attr("stroke-width", 2.5).attr("stroke-dasharray", "8,4");
  svg.append("text").attr("x", w/2 - 420).attr("y", layerY[1] - 8)
    .text("open-mcp-sysml").style("font-size", "18px").style("fill", "#E45756").style("font-weight", "bold");

  svg.append("line").attr("x1", w/2).attr("y1", layerY[0] + boxH/2)
    .attr("x2", w/2).attr("y2", layerY[1] - 30)
    .attr("stroke", "#999").attr("stroke-width", 2.5).attr("marker-end", "url(#arrowhead)");
  svg.append("text").attr("x", w/2 + 10).attr("y", (layerY[0] + boxH/2 + layerY[1] - 30) / 2 + 5)
    .text("MCP Protocol (stdio)").style("font-size", "16px").style("fill", "#666");

  const crateEdge = (sx, sy, tx, ty, tbw) => {
    const by = sy + boxH/2;
    const my = by + 55;
    const tx2 = tx - tbw * 0.15;
    svg.append("path")
      .attr("d", `M ${sx} ${by} C ${sx} ${my}, ${tx2} ${my}, ${tx2} ${ty + boxH/2}`)
      .attr("fill", "none").attr("stroke", "#999").attr("stroke-width", 2)
      .attr("marker-end", "url(#arrowhead)");
  };
  crateEdge(pos.mcp[0], pos.mcp[1], pos.parser[0], pos.parser[1], 230);
  crateEdge(pos.mcp[0], pos.mcp[1], pos.repo[0], pos.repo[1], 230);

  svg.append("line").attr("x1", pos.repo[0]).attr("y1", pos.repo[1] + boxH/2)
    .attr("x2", pos.git[0]).attr("y2", pos.git[1] - boxH/2)
    .attr("stroke", "#999").attr("stroke-width", 2.5).attr("marker-end", "url(#arrowhead)");
  svg.append("text").attr("x", pos.repo[0] + 10).attr("y", (pos.repo[1] + boxH/2 + pos.git[1] - boxH/2) / 2 + 5)
    .text("REST API").style("font-size", "16px").style("fill", "#666");

  const boxes = [
    {pos: pos.client, label: "AI Assistant (Client)", sub: "Claude, Copilot, or any MCP client", color: "#4C78A8", bw: 580},
    {pos: pos.mcp, label: "mcp-server", sub: "rmcp SDK", color: "#F58518", bw: 230},
    {pos: pos.parser, label: "sysml-parser", sub: "tree-sitter", color: "#72B7B2", bw: 230},
    {pos: pos.repo, label: "repo-client", sub: "GitLab ref impl", color: "#54A24B", bw: 230},
    {pos: pos.git, label: "Git Provider", sub: "GitLab API", color: "#B279A2", bw: 260}
  ];
  const gearX = w/2, gearY = layerY[1] + 62;
  const gearTeeth = 14, gearR = 44, toothR = 8, holeR = 14;
  const gearG = svg.append("g").attr("transform", `translate(${gearX},${gearY})`);
  const gn = gearTeeth, gr2 = gearR, gr0 = gr2 - toothR, gr1 = gr2 + toothR;
  const gda = Math.PI / gn;
  let ga0 = -Math.PI / 2;
  const gpath = [`M${gr0 * Math.cos(ga0)},${gr0 * Math.sin(ga0)}`];
  for (let gi = 0; gi < gn; gi++) {
    gpath.push(
      `A${gr0},${gr0} 0 0,1 ${gr0 * Math.cos(ga0 += gda)},${gr0 * Math.sin(ga0)}`,
      `L${gr2 * Math.cos(ga0)},${gr2 * Math.sin(ga0)}`,
      `L${gr1 * Math.cos(ga0 += gda/3)},${gr1 * Math.sin(ga0)}`,
      `A${gr1},${gr1} 0 0,1 ${gr1 * Math.cos(ga0 += gda/3)},${gr1 * Math.sin(ga0)}`,
      `L${gr2 * Math.cos(ga0 += gda/3)},${gr2 * Math.sin(ga0)}`,
      `L${gr0 * Math.cos(ga0)},${gr0 * Math.sin(ga0)}`
    );
  }
  gpath.push(`M0,${-holeR}A${holeR},${holeR} 0 0,0 0,${holeR}A${holeR},${holeR} 0 0,0 0,${-holeR}Z`);
  gearG.append("path").attr("d", gpath.join(""))
    .attr("fill", "#E45756").attr("opacity", 0.18).attr("stroke", "#E45756").attr("stroke-width", 1.5);
  const strats = ["L0/L1/L2", "Cache ID", "RTFM", "Meta-Tools", "KV-Opt", "Overflow", "Baseline"];
  strats.forEach((s, i) => {
    const angle = (i / strats.length) * Math.PI * 2 - Math.PI / 2;
    const lr = gr1 + 18;
    const lx = Math.cos(angle) * lr, ly = Math.sin(angle) * lr;
    gearG.append("text").attr("x", lx).attr("y", ly + 4)
      .attr("text-anchor", "middle")
      .text(s).style("font-size", "10px").style("fill", "#E45756").style("opacity", 0.85);
  });
  gearG.append("text").attr("y", gr1 + 38)
    .attr("text-anchor", "middle")
    .text("Token Reduction Engine").style("font-size", "13px").style("fill", "#E45756").style("font-weight", "bold");

  boxes.forEach(n => {
    const [cx, cy] = n.pos;
    svg.append("rect").attr("x", cx - n.bw/2).attr("y", cy - boxH/2)
      .attr("width", n.bw).attr("height", boxH).attr("rx", 10)
      .attr("fill", n.color).attr("opacity", 0.15).attr("stroke", n.color).attr("stroke-width", 2.5);
    svg.append("text").attr("x", cx).attr("y", cy - 8).attr("text-anchor", "middle")
      .text(n.label).style("font-size", "18px").style("font-weight", "bold");
    if (n.sub) svg.append("text").attr("x", cx).attr("y", cy + 18).attr("text-anchor", "middle")
      .text(n.sub).style("font-size", "14px").style("fill", "#666");
  });

  return svg.node();
}

Technology Choices

Decision	Choice	Rationale
Language	Rust 1.85	Memory safety, single binary, rmcp SDK
Parser	tree-sitter	Error recovery, incremental, 6 bindings
Transport	stdio	Sufficient for evaluation; HTTP planned
Git provider	GitLab (ref impl)	Trait-based; provider-agnostic design

Five MCP Tools (Phase 1)

Tool	Purpose	Token Cost
sysml_parse	Parse SysML v2 with L0/L1/L2 detail	100–2,000
sysml_validate	Return parse diagnostics	~300
sysml_list_definitions	List all definitions in model	~200
repo_list_files	List .sysml files in repo	~300
repo_get_file	Read file from repository	Variable

Token Reduction Strategies

Literature-informed strategies, each sourced from practitioner implementations:

#	Strategy	Reduction	Source
0	Vanilla (baseline)	0%	n/a
1	L0/L1/L2 Tiered ✅	~90-95%	OpenViking [5]
2	Cache ID + Summary	~97%	xc-mcp [6]
3	RTFM Docs	~80%	xc-mcp [6]
4	Two Meta-Tools	~95%	mcp-proxy [7]
5	KV-Cache Opt	10x cost	Manus [8]
6	Overflow Detection	Advisory	EACL 2026

Strategy 1 implemented in Phase 1. Strategies 2-6 defined in Phase 2 PRD with implementation timeline TBD; some may land within capstone scope depending on benchmark execution schedule.

Products: Near-Term & Far-Term

Near-Term (Capstone Scope, Apr 2026)

Deliverable	Status	Description
tree-sitter-sysml	✅ Complete	SysML v2 grammar: 99.6% coverage, 125 tests, 6 bindings
kebnf-to-tree-sitter	◐ In Progress	Automated KEBNF→tree-sitter converter, 640/640 rules parsed
open-mcp-sysml	✅ Phase 1	Rust MCP server: 5 tools, 22 tests, stdio transport
Capstone Book	◐ In Progress	15-chapter SE documentation (this Quarto book)
GVSETS 2026 Paper	◐ Drafted	AI-Augmented MBSE via MCP: draft Mar 23, final Jun 5

Key Metrics

• 2,236 lines of grammar.js
• 274/275 external SysML v2 files parsed (99.6%)
• 190/190 tree-sitter queries covered
• 93% automated KEBNF rule conversion (vs 60-70% estimated)
• ~25 hours total development time for grammar

Far-Term (Post-Capstone)

Deliverable	Timeline	Description
sysml.rs	Directed Study	Semantic analysis engine on tree-sitter-sysml
Grammar Transposition	Q3-Q4 2026	KEBNF methodology for INCOSE/SysEng Journal
INCOSE 2027 Benchmark	Q3 2027	SE benchmark for evaluating LLM capability
sysml-grammar-benchmark	Q2-Q3 2026	Comparative grammar dashboard (Quarto + D3)
MCP Server Phase 2	Post-capstone	Token reduction, HTTP transport, SysML v2 API

Directed Study Intent

We intend to continue this work as a directed study focused on:

1. sysml.rs: Rust-native semantic analysis (type checking, scope resolution, constraint evaluation for SysML v2)
2. INCOSE 2027: SE-specific benchmark evaluating LLM performance with and without MCP tooling
3. Conflict resolution: Resolving 335+ LR conflicts in the spec-driven grammar

The directed study builds directly on capstone infrastructure and targets two additional publications.

SE Process & Tailoring

INCOSE Processes Sampled

6 of 30+ processes, tailored per Handbook 5th Ed §4.3.4: “tailoring should be commensurate with project scope and risk”:

Artifact	INCOSE Process	Handbook §
SEP	Project Planning	2.3.4.1
Stakeholder Analysis	Stakeholder Needs & Req	2.3.5.2
SyRS	System Requirements Def	2.3.5.3
ADD	Architecture Definition	2.3.5.4
VVP	Verification & Validation	2.3.5.9, 2.3.5.11
RTM	Traceability	3.2.3

These 6 represent the minimum viable SE backbone for a software-intensive project: planning (SEP), requirements chain (Stakeholders → SyRS), design allocation (ADD), verification (VVP), and cross-cutting traceability (RTM). The 24+ processes omitted (Configuration Management, Decision Management, Integration, etc.) are either handled implicitly by Git/CI tooling or are not meaningful for a 3-person academic team over 15 weeks.

Tailoring Rationale

Constraint	Decision
15-week timeline	Combined SRR + PDR into single assessment
3-person team	Informal stakeholder validation via iterative dev
Academic scope	Interface requirements in ADD only (no IR-xxx IDs)
Implementation-first	Reviews after implementation; more meaningful

SRR and PDR conducted after initial implementation: requirements grounded in real constraints, architecture decisions validated by working code, review findings immediately actionable. Trade-off (scope commitment before formal review) mitigated by small team and rapid iteration.

Lifecycle: Hybrid Agile + Formal Gates

Phase	Weeks	Activities
Concept	1-2	Literature review, SEP, stakeholders
Design	3-4	SyRS, ADD, architecture selection
Implement	5-11	Grammar, MCP server, GVSETS paper
V&V + Ship	12-15	VVP execution, capstone delivery

// Traceability Sankey Diagram (artifactGraph)
// ----------------------------------------------
// Pattern: Left-to-right Sankey flow showing the full SE traceability chain.
//
// Layout strategy:
//   - 7 columns: Literature → Stakeholders → Needs → Requirements → System Reqs →
//     Architecture → Verification
//   - Nodes are thin vertical bars (nodeW=14px), height proportional to their value
//     (number of items they represent), scaled relative to the tallest column
//   - Links are cubic bezier curves (horizontal S-curves) with width proportional
//     to the number of traces flowing through that relationship
//   - Gradient strokes on links blend the source column color into the target column color
//
// Node positioning:
//   - Each column's nodes are vertically centered in the available height
//   - Spacing between nodes = scale * 1.5 (proportional gap)
//   - colNodes groups nodes by column index for layout calculation
//
// Link routing:
//   - srcOff/tgtOff track cumulative vertical offset per node to stack multiple
//     links without overlap (each link's width is added to the offset after drawing)
//   - Bezier control points use horizontal midpoint: M(sx,sy) C(mx,sy) (mx,ty) (tx,ty)
//
// Label placement:
//   - Columns 0-3: labels to the LEFT of the bar (text-anchor: end)
//   - Columns 4-6: labels to the RIGHT of the bar (text-anchor: start)
//   - Column headers are bold colored text above the diagram
//
// To add a node: append to nodes[] with {id, col, value, label}.
// To add a link: append to links[] with {s: sourceId, t: targetId, v: traceCount}.
// Gradient IDs are auto-generated from source-target names (spaces/parens sanitized).
artifactGraph = {
  const w = 1242, h = 932;
  const m = {top: 40, right: 30, bottom: 40, left: 30};
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, w, h])
    .attr("width", w).attr("height", h)
    .style("font-family", "system-ui, sans-serif")
    .style("margin-top", "20px");

  const colColors = ["#E45756", "#B279A2", "#4C78A8", "#4C78A8", "#72B7B2", "#54A24B", "#F58518"];
  const colLabels = ["Literature", "Stakeholders", "Needs (SN)", "Requirements (SR)", "System Reqs", "Architecture", "Verification"];
  const numCols = 7;
  const colW = (w - m.left - m.right) / numCols;
  const nodeW = 14;

  colLabels.forEach((label, i) => {
    svg.append("text")
      .attr("x", m.left + colW * i + colW / 2).attr("y", m.top - 12)
      .attr("text-anchor", "middle")
      .text(label).style("font-size", "14px").style("font-weight", "bold").style("fill", colColors[i]);
  });

  const nodes = [
    {id: "SysMBench", col: 0, value: 3, label: "SysMBench"},
    {id: "SysTemp", col: 0, value: 2, label: "SysTemp"},
    {id: "Bader", col: 0, value: 3, label: "Bader et al."},
    {id: "Ferrari", col: 0, value: 1, label: "Ferrari et al."},
    {id: "Darm", col: 0, value: 2, label: "Darm et al."},
    {id: "Li", col: 0, value: 2, label: "Li et al."},
    {id: "OpenViking", col: 0, value: 2, label: "OpenViking"},
    {id: "Manus", col: 0, value: 1, label: "Manus"},
    {id: "xc-mcp", col: 0, value: 2, label: "xc-mcp"},

    {id: "Advisor", col: 1, value: 2},
    {id: "Collaborator", col: 1, value: 1},
    {id: "OSS Community", col: 1, value: 2},
    {id: "Practitioners", col: 1, value: 5},
    {id: "GitLab", col: 1, value: 2},
    {id: "Implementers", col: 1, value: 2},
    {id: "INCOSE", col: 1, value: 1},
    {id: "DevOps", col: 1, value: 1},

    {id: "SN-Process", col: 2, value: 4, label: "Process (4)"},
    {id: "SN-Integration", col: 2, value: 3, label: "Integration (3)"},
    {id: "SN-Usability", col: 2, value: 4, label: "Usability (4)"},
    {id: "SN-Parsing", col: 2, value: 4, label: "Parsing (4)"},

    {id: "SR-Process", col: 3, value: 3, label: "Process (3)"},
    {id: "SR-Repo", col: 3, value: 3, label: "Repo/Deploy (3)"},
    {id: "SR-Docs", col: 3, value: 3, label: "Docs (3)"},
    {id: "SR-Parser", col: 3, value: 6, label: "Parser (6)"},

    {id: "FR-MCP", col: 4, value: 6, label: "FR-MCP (6)"},
    {id: "FR-REPO", col: 4, value: 7, label: "FR-REPO (7)"},
    {id: "FR-SYS", col: 4, value: 9, label: "FR-SYS (9)"},
    {id: "NFR-PERF", col: 4, value: 2, label: "NFR-PERF (2)"},
    {id: "NFR-SEC", col: 4, value: 3, label: "NFR-SEC (3)"},
    {id: "NFR-DEP", col: 4, value: 4, label: "NFR-DEP (4)"},
    {id: "NFR-DOC", col: 4, value: 3, label: "NFR-DOC (3)"},

    {id: "mcp-server", col: 5, value: 9, label: "mcp-server"},
    {id: "repo-client", col: 5, value: 7, label: "repo-client"},
    {id: "sysml-parser", col: 5, value: 7, label: "sysml-parser"},
    {id: "Build/Container", col: 5, value: 4, label: "Build/Container"},
    {id: "Documentation", col: 5, value: 3, label: "Documentation"},

    {id: "Test (26)", col: 6, value: 26, label: "Test (26)"},
    {id: "Demo (2)", col: 6, value: 2, label: "Demo (2)"},
    {id: "Inspect (6)", col: 6, value: 6, label: "Inspect (6)"}
  ];

  const links = [
    {s: "SysMBench", t: "Practitioners", v: 2},
    {s: "SysMBench", t: "Implementers", v: 1},
    {s: "SysTemp", t: "Practitioners", v: 1},
    {s: "SysTemp", t: "Implementers", v: 1},
    {s: "Bader", t: "Practitioners", v: 1},
    {s: "Bader", t: "OSS Community", v: 1},
    {s: "Bader", t: "GitLab", v: 1},
    {s: "Ferrari", t: "Practitioners", v: 1},
    {s: "Darm", t: "OSS Community", v: 1},
    {s: "Darm", t: "Practitioners", v: 1},
    {s: "Li", t: "Practitioners", v: 1},
    {s: "Li", t: "Implementers", v: 1},
    {s: "OpenViking", t: "GitLab", v: 1},
    {s: "OpenViking", t: "Practitioners", v: 1},
    {s: "Manus", t: "Practitioners", v: 1},
    {s: "xc-mcp", t: "OSS Community", v: 1},
    {s: "xc-mcp", t: "Practitioners", v: 1},

    {s: "Advisor", t: "SN-Process", v: 2},
    {s: "Collaborator", t: "SN-Process", v: 1},
    {s: "OSS Community", t: "SN-Integration", v: 2},
    {s: "Practitioners", t: "SN-Usability", v: 3},
    {s: "Practitioners", t: "SN-Parsing", v: 2},
    {s: "GitLab", t: "SN-Integration", v: 1},
    {s: "GitLab", t: "SN-Process", v: 1},
    {s: "Implementers", t: "SN-Parsing", v: 2},
    {s: "INCOSE", t: "SN-Process", v: 1},
    {s: "DevOps", t: "SN-Usability", v: 1},

    {s: "SN-Process", t: "SR-Process", v: 3},
    {s: "SN-Integration", t: "SR-Repo", v: 3},
    {s: "SN-Usability", t: "SR-Docs", v: 3},
    {s: "SN-Usability", t: "SR-Repo", v: 1},
    {s: "SN-Parsing", t: "SR-Parser", v: 4},

    {s: "SR-Process", t: "FR-MCP", v: 1},
    {s: "SR-Repo", t: "FR-REPO", v: 5},
    {s: "SR-Repo", t: "NFR-DEP", v: 3},
    {s: "SR-Docs", t: "NFR-DOC", v: 3},
    {s: "SR-Docs", t: "FR-SYS", v: 1},
    {s: "SR-Parser", t: "FR-SYS", v: 5},
    {s: "SR-Parser", t: "FR-MCP", v: 1},

    {s: "FR-MCP", t: "mcp-server", v: 6},
    {s: "FR-REPO", t: "repo-client", v: 7},
    {s: "FR-SYS", t: "sysml-parser", v: 7},
    {s: "FR-SYS", t: "mcp-server", v: 2},
    {s: "NFR-PERF", t: "mcp-server", v: 1},
    {s: "NFR-SEC", t: "mcp-server", v: 2},
    {s: "NFR-SEC", t: "repo-client", v: 1},
    {s: "NFR-DEP", t: "Build/Container", v: 4},
    {s: "NFR-DOC", t: "Documentation", v: 3},

    {s: "mcp-server", t: "Test (26)", v: 8},
    {s: "repo-client", t: "Test (26)", v: 6},
    {s: "sysml-parser", t: "Test (26)", v: 10},
    {s: "sysml-parser", t: "Inspect (6)", v: 2},
    {s: "Build/Container", t: "Test (26)", v: 2},
    {s: "Build/Container", t: "Demo (2)", v: 2},
    {s: "Documentation", t: "Inspect (6)", v: 3}
  ];

  const colNodes = Array.from({length: numCols}, (_, i) => nodes.filter(n => n.col === i));
  const maxColValue = d3.max(colNodes, ns => d3.sum(ns, n => n.value));
  const availH = h - m.top - m.bottom - 60;
  const scale = availH / (maxColValue + colNodes[0].length * 2);

  const nodePos = {};
  colNodes.forEach((ns, ci) => {
    const totalH = d3.sum(ns, n => n.value * scale) + (ns.length - 1) * scale * 1.5;
    let cy = m.top + 30 + (availH - totalH) / 2;
    ns.forEach(n => {
      const nh = n.value * scale;
      nodePos[n.id] = {
        x: m.left + ci * colW + (colW - nodeW) / 2,
        y: cy, h: nh, col: ci
      };
      cy += nh + scale * 1.5;
    });
  });

  const srcOff = {}, tgtOff = {};
  nodes.forEach(n => { srcOff[n.id] = 0; tgtOff[n.id] = 0; });

  links.forEach(l => {
    const sp = nodePos[l.s], tp = nodePos[l.t];
    const lw = Math.max(l.v * scale * 0.6, 2);
    const sx = sp.x + nodeW, sy = sp.y + srcOff[l.s] + lw / 2;
    const tx = tp.x, ty = tp.y + tgtOff[l.t] + lw / 2;
    const mx = (sx + tx) / 2;

    const sc = colColors[sp.col], tc = colColors[tp.col];
    const gid = `sg-${l.s}-${l.t}`.replace(/[\s()]/g, "_");
    const grad = svg.append("defs").append("linearGradient")
      .attr("id", gid).attr("gradientUnits", "userSpaceOnUse")
      .attr("x1", sx).attr("y1", 0).attr("x2", tx).attr("y2", 0);
    grad.append("stop").attr("offset", "0%").attr("stop-color", sc).attr("stop-opacity", 0.35);
    grad.append("stop").attr("offset", "100%").attr("stop-color", tc).attr("stop-opacity", 0.35);

    svg.append("path")
      .attr("d", `M${sx},${sy} C${mx},${sy} ${mx},${ty} ${tx},${ty}`)
      .attr("fill", "none").attr("stroke", `url(#${gid})`)
      .attr("stroke-width", lw);

    srcOff[l.s] += lw;
    tgtOff[l.t] += lw;
  });

  nodes.forEach(n => {
    const p = nodePos[n.id];
    const c = colColors[n.col];
    svg.append("rect")
      .attr("x", p.x).attr("y", p.y)
      .attr("width", nodeW).attr("height", p.h).attr("rx", 3)
      .attr("fill", c).attr("opacity", 0.7);
    const label = n.label || n.id;
    const textX = n.col <= 3 ? p.x - 6 : p.x + nodeW + 6;
    const anchor = n.col <= 3 ? "end" : "start";
    svg.append("text")
      .attr("x", textX).attr("y", p.y + p.h / 2 + 4)
      .attr("text-anchor", anchor)
      .text(label).style("font-size", "13px").style("fill", "#444");
  });

  svg.append("text").attr("x", w / 2).attr("y", h - 8)
    .attr("text-anchor", "middle")
    .text("18 Papers → 8 Stakeholders → 15 Needs → 15 Requirements → 34 System Reqs → 7 Components → 34 Verifications")
    .style("font-size", "13px").style("fill", "#999").style("font-style", "italic");

  return svg.node();
}

Stakeholders & Requirements Flow

Why Formal Stakeholder Analysis?

We didn’t just build a tool. Per INCOSE Handbook §2.3.5.2, we identified 8 stakeholders, elicited 15 needs, derived 15 stakeholder requirements, and decomposed those into 34 system requirements. This discipline ensures the system serves real users, not assumed ones.

Stakeholder Categories

Category	Stakeholders	Strategy	Key Needs
Primary	Advisor, Collaborator	Manage Closely	SE methodology, defensible deliverables
Practitioners	OSS Community, MBSE Practitioners	Keep Satisfied	Git integration, single binary, CI/CD examples
Ecosystem	GitLab, SysML v2 Implementers	Keep Informed	GVSETS demo, spec conformance
Community	INCOSE, Sensmetry	Monitor / Inform	Novel contribution, interoperability

Requirements Traceability Chain

8 stakeholders → 15 needs → 15 requirements → 34 system requirements

The 15 stakeholder needs (SN-001 through SN-015) trace to 15 stakeholder requirements (SR-001 through SR-015) with some many-to-one mappings. These decompose into 34 system requirements spanning functional (FR), non-functional (NFR), and interface (IR) specifications.

Representative needs driving the design:

• SN-001 (OSS Community): Git provider API integration for existing repositories
• SN-007 (Practitioners): Easy installation (single binary, no dependencies)
• SN-012 (Practitioners): Model validation against SysML v2 spec
• SN-014 (Implementers): OMG spec conformance in parsing

Power / Interest Analysis

// Power/Interest Stakeholder Map (stakeholderMap)
// -------------------------------------------------
// Pattern: 2x2 quadrant scatter plot (Power vs Interest matrix).
//
// Layout strategy:
//   - X axis = Interest (0→1), Y axis = Power (0→1)
//   - Four colored quadrant backgrounds: Monitor (grey), Keep Informed (green),
//     Keep Satisfied (orange), Manage Closely (blue)
//   - Dashed lines at x=0.5 and y=0.5 divide the quadrants
//   - Each stakeholder is a colored circle at (x, y) with label offset to the right
//
// Quadrant assignment:
//   - Top-right (high power, high interest) = Manage Closely
//   - Top-left (high power, low interest) = Keep Satisfied
//   - Bottom-right (low power, high interest) = Keep Informed
//   - Bottom-left (low power, low interest) = Monitor
//
// To move a stakeholder: change its x/y values in the stk array (0-1 range).
// To add a stakeholder: append to stk[] with {name, x, y, color}.
stakeholderMap = {
  const w = 1210, h = 965;
  const m = {top: 40, right: 40, bottom: 60, left: 70};
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, w, h])
    .attr("width", w).attr("height", h)
    .style("font-family", "system-ui, sans-serif");

  const xS = d3.scaleLinear().domain([0, 1]).range([m.left, w - m.right]);
  const yS = d3.scaleLinear().domain([0, 1]).range([h - m.bottom, m.top]);

  const quadrants = [
    {x: 0, y: 0.5, w: 0.5, h: 0.5, label: "Monitor", fill: "#f5f5f5"},
    {x: 0.5, y: 0.5, w: 0.5, h: 0.5, label: "Keep Informed", fill: "#e8f4e8"},
    {x: 0, y: 0, w: 0.5, h: 0.5, label: "Keep Satisfied", fill: "#fff3e0"},
    {x: 0.5, y: 0, w: 0.5, h: 0.5, label: "Manage Closely", fill: "#e3f2fd"}
  ];
  quadrants.forEach(q => {
    svg.append("rect")
      .attr("x", xS(q.x)).attr("y", yS(q.y + q.h))
      .attr("width", xS(q.x + q.w) - xS(q.x))
      .attr("height", yS(q.y) - yS(q.y + q.h))
      .attr("fill", q.fill);
    svg.append("text")
      .attr("x", xS(q.x + q.w / 2)).attr("y", yS(q.y + q.h) + 18)
      .attr("text-anchor", "middle")
      .text(q.label).style("font-size", "13px").style("fill", "#aaa").style("font-weight", "bold");
  });

  svg.append("line").attr("x1", xS(0.5)).attr("y1", yS(0)).attr("x2", xS(0.5)).attr("y2", yS(1))
    .attr("stroke", "#ccc").attr("stroke-dasharray", "4,3");
  svg.append("line").attr("x1", xS(0)).attr("y1", yS(0.5)).attr("x2", xS(1)).attr("y2", yS(0.5))
    .attr("stroke", "#ccc").attr("stroke-dasharray", "4,3");

  const stk = [
    {name: "Academic Advisor", x: 0.85, y: 0.92, color: "#4C78A8"},
    {name: "Capstone Collaborator", x: 0.75, y: 0.80, color: "#4C78A8"},
    {name: "Open Source Community", x: 0.78, y: 0.40, color: "#54A24B"},
    {name: "GitLab", x: 0.70, y: 0.72, color: "#F58518"},
    {name: "MBSE Practitioners", x: 0.80, y: 0.35, color: "#54A24B"},
    {name: "SysML v2 Implementers", x: 0.55, y: 0.40, color: "#F58518"},
    {name: "INCOSE/SE Community", x: 0.35, y: 0.25, color: "#72B7B2"},
    {name: "Sensmetry (Sysand)", x: 0.42, y: 0.18, color: "#72B7B2"}
  ];

  svg.selectAll("circle.stk")
    .data(stk).join("circle")
    .attr("cx", d => xS(d.x)).attr("cy", d => yS(d.y))
    .attr("r", 10).attr("fill", d => d.color).attr("opacity", 0.7)
    .attr("stroke", d => d.color).attr("stroke-width", 2);

  svg.selectAll("text.stk")
    .data(stk).join("text")
    .attr("x", d => xS(d.x) + 14).attr("y", d => yS(d.y) + 5)
    .text(d => d.name).style("font-size", "12px").style("fill", "#333");

  svg.append("text").attr("x", (m.left + w - m.right) / 2).attr("y", h - 6)
    .attr("text-anchor", "middle").text("Interest →")
    .style("font-size", "14px").style("fill", "#666");
  svg.append("text").attr("x", 16).attr("y", (m.top + h - m.bottom) / 2)
    .attr("text-anchor", "middle").attr("transform", `rotate(-90, 16, ${(m.top + h - m.bottom) / 2})`)
    .text("Power →").style("font-size", "14px").style("fill", "#666");

  return svg.node();
}

SE Artifacts & Review Status

Artifacts Produced

Artifact	Ch	Key Content
SEP	6	Lifecycle, risk register, gates
Stakeholders	8	8 stakeholders, 15 needs/reqs
SyRS	9	34 requirements (FR/NFR/IR)
ADD	10	3-crate arch, tool specs
VVP	11	11/34 verified, VMA matrix
RTM	16	SN→SR→SyR→Test trace

~4,500 lines across 15 chapters

Review Gates

Gate	Date	Status
SRR	Feb 14	✅ Complete
PDR	Feb 14	✅ Complete
CDR	Mar 29	⏳ Pending

Both passed with caveats reflecting our implementation-first approach:

• SRR: Interface requirements deferred (documented in ADD); stakeholder validation conducted iteratively; requirements baselined with understanding that benchmark execution may drive updates
• PDR: VVP requirement IDs reconciled (FR-Umcp → FR-MCP naming); ADD tool definitions updated to match implementation
• All action items resolved except VVP test case updates (in progress for CDR)

Risk Register

Risk	Status
R1: SysML v2 API availability	Mitigated
R2: GVSETS deadline pressure	Open
R3: Grammar complexity	Closed (99.6%)
R4: MCP SDK maturity	Closed
R5: Container deployment	Planned (CI/Linux)
R6: Benchmark validity	Mitigated
R7: Spec-driven conflicts	Closed
R8: Team availability	Closed
R9: tree-sitter org acceptance	Open

4 closed, 2 mitigated, 1 planned, 2 open. No risk ≥ escalation threshold.

VMA Coverage

11/34 requirements verified, covering the highest-risk requirements verifiable through current test infrastructure. Planned methods across all 34: 26 by Test (automated CI), 2 by Demonstration (manual), 6 by Inspection (review).

The 23 deferred requirements span HTTP transport, SysML v2 API integration, repository write operations, and security, all Phase 2+ features. CDR (Mar 29) is the next verification checkpoint.

WBS Structure

wbsData = ({
  name: "1.0 Project", pct: 66, children: [
    {name: "1.1 Mgmt", pct: 90, children: [
      {name: "Planning", done: true},
      {name: "Reviews", done: false},
      {name: "Risk Mgmt", done: true}
    ]},
    {name: "1.2 SE", pct: 100, children: [
      {name: "SEP", done: true, children: [
        {name: "Lifecycle model", done: true},
        {name: "Review criteria", done: true},
        {name: "Config mgmt", done: true}
      ]},
      {name: "Stakeholders", done: true},
      {name: "SyRS", done: true},
      {name: "ADD", done: true},
      {name: "VVP", done: true},
      {name: "RTM", done: true}
    ]},
    {name: "1.3 SW Dev", pct: 66, children: [
      {name: "tree-sitter-sysml", done: true, children: [
        {name: "Grammar (2,236 LOC)", done: true},
        {name: "Corpus (125 tests)", done: true},
        {name: "6 bindings", done: true}
      ]},
      {name: "kebnf-to-ts", done: false, children: [
        {name: "Parser (640 rules)", done: true},
        {name: "Emitter", done: true},
        {name: "Conflict resolution", done: false}
      ]},
      {name: "open-mcp-sysml", done: false, children: [
        {name: "Phase 1 (5 tools)", done: true},
        {name: "Phase 2 (tokens)", done: false}
      ]},
      {name: "Benchmark", done: false}
    ]},
    {name: "1.4 Infra", pct: 60, children: [
      {name: "Repos", done: true},
      {name: "CI/CD", done: true},
      {name: "Container", done: false}
    ]},
    {name: "1.5 Docs", pct: 46, children: [
      {name: "Quarto Book", done: true},
      {name: "READMEs", done: true},
      {name: "Lit Review", done: false}
    ]},
    {name: "1.6 Deliverables", pct: 36, children: [
      {name: "GVSETS", done: false},
      {name: "Grammar Paper", done: false},
      {name: "Capstone", done: false}
    ]}
  ]
})

wbsTree = {
  const w = 906, h = 1129;
  const ml = 125, mr = 210, mt = 12, mb = 12;
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, w, h])
    .attr("width", w).attr("height", h)
    .style("font-family", "system-ui, sans-serif");

  const root = d3.hierarchy(wbsData);
  d3.tree().size([h - mt - mb, w - ml - mr])(root);

  const catColor = d3.scaleOrdinal()
    .domain(["1.1 Mgmt", "1.2 SE", "1.3 SW Dev", "1.4 Infra", "1.5 Docs", "1.6 Deliverables"])
    .range(["#4C78A8", "#54A24B", "#E45756", "#F58518", "#72B7B2", "#B279A2"]);

  const pctColor = (p) => p >= 80 ? "#54A24B" : p >= 50 ? "#F58518" : "#E45756";

  const ancestor1 = (d) => {
    let n = d;
    while (n.depth > 1) n = n.parent;
    return n.data.name;
  };

  const g = svg.append("g").attr("transform", `translate(${ml},${mt})`);

  g.selectAll("path.link")
    .data(root.links()).join("path")
    .attr("d", d3.linkHorizontal().x(d => d.y).y(d => d.x))
    .attr("fill", "none")
    .attr("stroke", d => {
      const cat = d.source.depth === 0 ? d.target.data.name : ancestor1(d.source);
      return catColor(cat) || "#ccc";
    })
    .attr("stroke-opacity", 0.4).attr("stroke-width", 1.5);

  const node = g.selectAll("g.node")
    .data(root.descendants()).join("g")
    .attr("transform", d => `translate(${d.y},${d.x})`);

  node.filter(d => d.depth >= 2).append("circle")
    .attr("r", d => d.depth === 2 ? 6 : 4.5)
    .attr("fill", d => d.data.done ? "#54A24B" : "#ddd")
    .attr("stroke", d => d.data.done ? "#54A24B" : "#999")
    .attr("stroke-width", 2);

  node.filter(d => d.depth === 1).append("rect")
    .attr("x", -10).attr("y", -10).attr("width", 20).attr("height", 20).attr("rx", 4)
    .attr("fill", d => catColor(d.data.name))
    .attr("opacity", 0.2)
    .attr("stroke", d => catColor(d.data.name))
    .attr("stroke-width", 2.5);

  node.filter(d => d.depth === 0).append("circle")
    .attr("r", 10).attr("fill", "#333");

  node.filter(d => d.depth === 0).append("text")
    .attr("dy", "0.35em").attr("x", -16).attr("text-anchor", "end")
    .text(d => d.data.name)
    .style("font-size", "16px").style("font-weight", "bold");

  node.filter(d => d.depth === 0).append("text")
    .attr("dy", "0.35em").attr("x", -16).attr("y", 20).attr("text-anchor", "end")
    .text(d => `${d.data.pct}% complete`)
    .style("font-size", "14px").style("fill", "#666");

  node.filter(d => d.depth === 1).append("text")
    .attr("dy", "-16").attr("text-anchor", "middle")
    .text(d => d.data.name)
    .style("font-size", "14px").style("font-weight", "bold")
    .style("fill", d => catColor(d.data.name));

  node.filter(d => d.depth === 1).append("text")
    .attr("dy", "26").attr("text-anchor", "middle")
    .text(d => `${d.data.pct}%`)
    .style("font-size", "12px").style("font-weight", "bold")
    .style("fill", d => pctColor(d.data.pct));

  node.filter(d => d.depth >= 2).append("text")
    .attr("dy", "0.35em").attr("x", d => d.children ? -10 : 10)
    .attr("text-anchor", d => d.children ? "end" : "start")
    .text(d => d.data.name)
    .style("font-size", d => d.depth === 2 ? "12px" : "11px")
    .style("fill", d => d.data.done ? "#333" : "#999");

  const legend = svg.append("g").attr("transform", `translate(${w - 160}, ${h - 60})`);
  [{label: "Complete", color: "#54A24B"}, {label: "In Progress", color: "#ddd", stroke: "#999"}].forEach((l, i) => {
    const lg = legend.append("g").attr("transform", `translate(0, ${i * 24})`);
    lg.append("circle").attr("r", 5).attr("fill", l.color).attr("stroke", l.stroke || l.color).attr("stroke-width", 2);
    lg.append("text").attr("x", 12).attr("dy", "0.35em").text(l.label).style("font-size", "12px");
  });

  return svg.node();
}

Implementation Results

tree-sitter-sysml (Grammar)

Metric	Value
Training file coverage	100% (100/100 OMG files)
External file coverage	99.6% (274/275 files)
Corpus tests	125/125 passing
Query coverage	190/190
Grammar size	~2,236 lines
Development time	~25 hours
Language bindings	C, Rust, Go, Python, Node.js, Swift

kebnf-to-tree-sitter (Converter)

Metric	Value
KEBNF rules parsed	640/640 (100%)
Direct conversion	38% of rules
Strip-and-convert	55% of rules
Total automation	93% (vs 60-70% estimated)
LR conflicts remaining	335+ (vs 54 in brute-force)
Development time	~12 hours (vs 60-100h estimated)

open-mcp-sysml (MCP Server)

Metric	Value
Crates	3 (mcp-server, sysml-parser, repo-client)
MCP tools	5 implemented
Tests	22 passing
Development time	~20 hours

Dual-Path Grammar Strategy

Two independent paths to SysML v2 grammar, validated by cross-comparison:

	Brute-Force	Spec-Driven
Repository	tree-sitter-sysml	kebnf-to-tree-sitter
Method	Empirical: study corpus	Formal: parse OMG KEBNF
Authoring	Manual grammar.js	Automated rule generation
Conflicts	54 (resolved)	335+ (in progress)
Status	✅ Production ready	◐ Research contribution
Value	Immediate practical use	Reproducibility + INCOSE paper

Cross-validation found 12 grammar rules where brute-force diverged from spec intent; each path catches errors the other misses.

Research Infrastructure

The dual-path grammar + MCP server form infrastructure for post-masters study and continued contributions:

• sysml.rs (directed study): Semantic analysis engine built on tree-sitter-sysml. Import resolution, type checking, constraint evaluation beyond syntax-only parsing
• Grammar transposition (INCOSE/SysEng Journal): The spec-driven converter targets a methodology paper on automated KEBNF-to-tree-sitter conversion
• INCOSE 2027 benchmark: Grammar + MCP server enable evaluating LLM performance on SE tasks with and without structured tooling

AI-Augmented Meta-Process

The SE / LSE Dialectic

We designed a multi-persona AI workflow where two personas with deliberate tension produce better artifacts than either alone:

// SE/LSE Dialectic Diagram (dialecticSvg)
// -----------------------------------------
// Pattern: Two opposing boxes with bidirectional arrows converging to a result.
//
// Layout strategy:
//   - Two persona boxes at top (seX=240, lseX=710) with role, quote, and description
//   - Bidirectional horizontal arrows between them (offset ±16px vertically to avoid overlap)
//   - A result box at bottom center with convergent diagonal arrows from both personas
//
// Each persona box:
//   - Rounded rect (380x140) with low-opacity color fill + solid stroke
//   - Bold title, italic quote, and detail text (supports \n via .split("\n"))
//
// Arrow markers: uses a shared "dArrow" marker definition (smaller than architecture arrows).
// The two horizontal arrows are offset vertically (topY-16 and topY+16) to show
// bidirectional flow without overlapping.
//
// To adjust spacing: modify seX/lseX for horizontal, topY/botY for vertical positioning.
dialecticSvg = {
  const w = 1045, h = 462;
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, w, h])
    .attr("width", w).attr("height", h)
    .style("font-family", "system-ui, sans-serif");

  svg.append("defs").append("marker").attr("id", "dArrow")
    .attr("viewBox", "0 0 10 10").attr("refX", 10).attr("refY", 5)
    .attr("markerWidth", 7).attr("markerHeight", 7).attr("orient", "auto")
    .append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("fill", "#999");

  const seX = 240, lseX = 710, topY = 100, botY = 360;

  [{x: seX, y: topY, label: "Systems Engineer", sub: '"What does the handbook say?"',
    detail: "Drafts comprehensively with\nfull INCOSE alignment", color: "#4C78A8"},
   {x: lseX, y: topY, label: "Lead Systems Engineer", sub: '"Is this necessary for THIS project?"',
     detail: "Prunes pragmatically with\ntailoring rationale", color: "#54A24B"}
  ].forEach(n => {
    svg.append("rect").attr("x", n.x - 190).attr("y", n.y - 70).attr("width", 380).attr("height", 140)
      .attr("rx", 12).attr("fill", n.color).attr("opacity", 0.12).attr("stroke", n.color).attr("stroke-width", 2.5);
    svg.append("text").attr("x", n.x).attr("y", n.y - 36).attr("text-anchor", "middle")
      .text(n.label).style("font-size", "20px").style("font-weight", "bold");
    svg.append("text").attr("x", n.x).attr("y", n.y - 8).attr("text-anchor", "middle")
      .text(n.sub).style("font-size", "16px").style("fill", "#666").style("font-style", "italic");
    n.detail.split("\n").forEach((line, i) => {
      svg.append("text").attr("x", n.x).attr("y", n.y + 22 + i * 22).attr("text-anchor", "middle")
        .text(line).style("font-size", "16px").style("fill", "#555");
    });
  });

  svg.append("line").attr("x1", seX + 190).attr("y1", topY - 16)
    .attr("x2", lseX - 190).attr("y2", topY - 16)
    .attr("stroke", "#999").attr("stroke-width", 2).attr("marker-end", "url(#dArrow)");
  svg.append("line").attr("x1", lseX - 190).attr("y1", topY + 16)
    .attr("x2", seX + 190).attr("y2", topY + 16)
    .attr("stroke", "#999").attr("stroke-width", 2).attr("marker-end", "url(#dArrow)");

  svg.append("rect").attr("x", w/2 - 300).attr("y", botY - 32).attr("width", 600).attr("height", 64)
    .attr("rx", 12).attr("fill", "#F58518").attr("opacity", 0.15).attr("stroke", "#F58518").attr("stroke-width", 2.5);
  svg.append("text").attr("x", w/2).attr("y", botY + 8).attr("text-anchor", "middle")
    .text("Better artifacts than either persona alone").style("font-size", "20px").style("font-weight", "bold");

  const off = w * 0.15;
  svg.append("line").attr("x1", seX).attr("y1", topY + 70).attr("x2", w/2 - off).attr("y2", botY - 32)
    .attr("stroke", "#ccc").attr("stroke-width", 1.5).attr("marker-end", "url(#dArrow)");
  svg.append("line").attr("x1", lseX).attr("y1", topY + 70).attr("x2", w/2 + off).attr("y2", botY - 32)
    .attr("stroke", "#ccc").attr("stroke-width", 1.5).attr("marker-end", "url(#dArrow)");

  return svg.node();
}

Three-Tier Model Allocation

Tier	Model	Purpose	Context
Orchestrator	Opus	Cross-project decisions, consistency	Full estate
Worker	Sonnet	Single-project implementation	Project scope
Scout	Haiku/Flash	File search, status checks	Minimal

Token-cost-aware: expensive models for cross-cutting decisions, cheaper models for bounded tasks. Inspired by Yegge’s Gas Town orchestration pattern and Beads git-backed memory [9]; adapted to a minimal file-based approach (ESTATE.md + DISPATCH.md + memory/) that provides the coordination value without the infrastructure complexity.

Seven Skill Personas

Skill	Role	Runs As
systems-engineer	INCOSE-aligned drafting	Subagent
lead-systems-engineer	Pragmatic review + tailoring	Subagent
upstream	MCP/SysML/INCOSE spec lookup	Subagent
mcp-builder	Implementation guidance	Subagent
publisher	Academic writing (GVSETS, INCOSE)	Main ctx
diagrammer	Precision ASCII/Unicode diagrams	Main ctx
quarto	Build validation before push	Main ctx

Estate-Level Orchestration

// Estate Organization Diagram (estateSvg)
// ------------------------------------------
// Pattern: Horizontal dendrogram using d3.hierarchy() + d3.tree() + d3.linkHorizontal().
//
// Data structure: nested JSON with {name, desc, color, children}.
// Three main branches: ESTATE.md, DISPATCH.md, memory/ — each with leaf items.
//
// Layout: d3.tree().size([h-120, w-420]) with translate(120, 60) offset.
// Node sizing by depth: root=10r, depth1=9r, depth2=7r.
// Colors propagate from depth-1 parent to depth-2 children via d.parent.data.color.
// Depth-1 nodes show description text below (dy=28).
// Depth-2 leaf labels are placed to the right (dx=12, text-anchor: start).
estateSvg = {
  const w = 1155, h = 825;
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, w, h])
    .attr("width", w).attr("height", h)
    .style("font-family", "system-ui, sans-serif");

  const treeData = {
    name: "Orchestration", children: [
      {name: "ESTATE.md", desc: "Single source of truth", color: "#4C78A8", children: [
        {name: "7 project statuses"}, {name: "Dependency graph"},
        {name: "Shared metrics"}, {name: "Discrepancy tracker"},
        {name: "Traversal Protocol"}
      ]},
      {name: "DISPATCH.md", desc: "Coordination bus", color: "#E45756", children: [
        {name: "D-001: Phase 1 → capstone"}, {name: "D-002: Corpus → README"},
        {name: "D-003: Token strategy sync"}
      ]},
      {name: "memory/", desc: "Cross-session learning", color: "#54A24B", children: [
        {name: "decision"}, {name: "tailoring"}, {name: "convention"},
        {name: "bugfix"}, {name: "discovery"}
      ]}
    ]
  };

  const root = d3.hierarchy(treeData);
  const treeLayout = d3.tree().size([h - 120, w - 420]);
  treeLayout(root);

  svg.append("g").attr("transform", "translate(120, 60)")
    .selectAll("path.link")
    .data(root.links()).join("path")
    .attr("d", d3.linkHorizontal().x(d => d.y).y(d => d.x))
    .attr("fill", "none").attr("stroke", "#ccc").attr("stroke-width", 2.5);

  const node = svg.append("g").attr("transform", "translate(120, 60)")
    .selectAll("g.node")
    .data(root.descendants()).join("g")
    .attr("transform", d => `translate(${d.y},${d.x})`);

  node.append("circle").attr("r", d => d.depth === 0 ? 10 : d.depth === 1 ? 9 : 7)
    .attr("fill", d => d.data.color || (d.parent ? d.parent.data.color : "#999") || "#999");

  node.filter(d => d.depth === 0).append("text")
    .attr("dy", -18).attr("text-anchor", "middle")
    .text(d => d.data.name).style("font-size", "20px").style("font-weight", "bold");

  node.filter(d => d.depth === 1).append("text")
    .attr("dy", -18).attr("text-anchor", "middle")
    .text(d => d.data.name).style("font-size", "18px").style("font-weight", "bold");

  node.filter(d => d.depth === 1).append("text")
    .attr("dy", 28).attr("text-anchor", "middle")
    .text(d => d.data.desc).style("font-size", "14px").style("fill", "#666");

  node.filter(d => d.depth === 2).append("text")
    .attr("dy", "0.35em").attr("dx", 12).attr("text-anchor", "start")
    .text(d => d.data.name).style("font-size", "15px").style("fill", "#444");

  return svg.node();
}

Iteration & Evolution

d3 = require("d3@7")

// Streamgraph (commitData + svg)
// --------------------------------
// Pattern: Stacked area chart with wiggle offset (streamgraph) showing commit
// activity across 6 repositories over time.
//
// Data: array of {date, capstone, tssysml, kebnf, mcp, gvsets, bench} per day.
// Stack: d3.stack() with stackOffsetWiggle (centered, organic shape) and
//   stackOrderInsideOut (largest streams in center for visual balance).
// Area: d3.area() with curveBasis for smooth interpolation.
// X scale: d3.scaleTime() from first to last date.
// Y scale: d3.scaleLinear() auto-fitted to stacked min/max.
// Colors: d3.schemeTableau10 mapped to repository keys.
//
// Legend is positioned at right margin. Title shows total commits and timespan.
// To add a day: append to commitData[]. To add a repo: add key to keys[], labels{}.
commitData = [
  {date: "2026-01-21", capstone: 10, tssysml: 0, kebnf: 0, mcp: 0, gvsets: 0, bench: 0},
  {date: "2026-01-22", capstone: 4, tssysml: 0, kebnf: 0, mcp: 0, gvsets: 0, bench: 0},
  {date: "2026-01-23", capstone: 1, tssysml: 0, kebnf: 0, mcp: 0, gvsets: 0, bench: 0},
  {date: "2026-01-24", capstone: 40, tssysml: 0, kebnf: 0, mcp: 0, gvsets: 0, bench: 0},
  {date: "2026-01-25", capstone: 19, tssysml: 0, kebnf: 0, mcp: 0, gvsets: 0, bench: 0},
  {date: "2026-01-26", capstone: 4, tssysml: 0, kebnf: 0, mcp: 0, gvsets: 0, bench: 0},
  {date: "2026-02-06", capstone: 1, tssysml: 0, kebnf: 0, mcp: 0, gvsets: 0, bench: 0},
  {date: "2026-02-09", capstone: 14, tssysml: 15, kebnf: 0, mcp: 4, gvsets: 0, bench: 0},
  {date: "2026-02-10", capstone: 13, tssysml: 41, kebnf: 12, mcp: 3, gvsets: 0, bench: 0},
  {date: "2026-02-11", capstone: 14, tssysml: 9, kebnf: 2, mcp: 1, gvsets: 4, bench: 0},
  {date: "2026-02-12", capstone: 9, tssysml: 7, kebnf: 0, mcp: 0, gvsets: 2, bench: 0},
  {date: "2026-02-13", capstone: 5, tssysml: 9, kebnf: 3, mcp: 5, gvsets: 3, bench: 2},
  {date: "2026-02-14", capstone: 34, tssysml: 8, kebnf: 0, mcp: 1, gvsets: 0, bench: 0}
]

keys = ["capstone", "tssysml", "kebnf", "mcp", "gvsets", "bench"]

labels = ({
  capstone: "Capstone Book",
  tssysml: "tree-sitter-sysml",
  kebnf: "kebnf-to-tree-sitter",
  mcp: "open-mcp-sysml",
  gvsets: "GVSETS Paper",
  bench: "Grammar Benchmark"
})

width = 1725
height = 863
marginTop = 40
marginRight = 200
marginBottom = 50
marginLeft = 60

parseDate = d3.timeParse("%Y-%m-%d")
data = commitData.map(d => ({...d, date: parseDate(d.date)}))

x = d3.scaleTime()
  .domain(d3.extent(data, d => d.date))
  .range([marginLeft, width - marginRight])

stack = d3.stack()
  .keys(keys)
  .offset(d3.stackOffsetWiggle)
  .order(d3.stackOrderInsideOut)

series = stack(data)

y = d3.scaleLinear()
  .domain([
    d3.min(series, s => d3.min(s, d => d[0])),
    d3.max(series, s => d3.max(s, d => d[1]))
  ])
  .range([height - marginBottom, marginTop])

color = d3.scaleOrdinal()
  .domain(keys)
  .range(d3.schemeTableau10)

area = d3.area()
  .x(d => x(d.data.date))
  .y0(d => y(d[0]))
  .y1(d => y(d[1]))
  .curve(d3.curveBasis)

svg = {
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("width", width)
    .attr("height", height)
    .style("font-family", "system-ui, sans-serif");

  svg.selectAll("path")
    .data(series)
    .join("path")
    .attr("d", area)
    .attr("fill", d => color(d.key))
    .attr("opacity", 0.85)
    .append("title")
    .text(d => labels[d.key]);

  svg.append("g")
    .attr("transform", `translate(0,${height - marginBottom})`)
    .call(d3.axisBottom(x).ticks(d3.timeDay.every(2)).tickFormat(d3.timeFormat("%b %d")))
    .call(g => g.select(".domain").remove())
    .selectAll("text")
    .style("font-size", "14px");

  const legend = svg.append("g")
    .attr("transform", `translate(${width - marginRight + 20}, ${marginTop + 60})`);

  keys.forEach((key, i) => {
    const g = legend.append("g").attr("transform", `translate(0, ${i * 28})`);
    g.append("rect").attr("width", 20).attr("height", 20).attr("fill", color(key)).attr("opacity", 0.85);
    g.append("text").attr("x", 28).attr("y", 15).text(labels[key]).style("font-size", "15px");
  });

  svg.append("text")
    .attr("x", width / 2 - 80)
    .attr("y", marginTop - 10)
    .style("font-size", "20px")
    .style("font-weight", "bold")
    .text("299 commits across 6 repositories, 25 days");

  return svg.node();
}

The streamgraph reveals a clear phase transition: capstone-only work (Jan) gave way to simultaneous multi-repo development (Feb 9+). The widening bands show how grammar, server, and paper work fed each other; cross-project commits on the same day were the norm, not the exception.

By the Numbers

Metric	Value
Total commits	299
Repositories	6
Active days	13 of 25 calendar days
Peak day	Feb 10 (69 commits)
Capstone lines	~4,500 across 15 chapters
Capstone commits	168
Literature entries	18 papers reviewed

Evolution Narrative

Phase 1 (Jan 21-26): Capstone foundation: SEP, literature review, stakeholder analysis, initial architecture. 78 commits in 6 days.

Quiet period (Jan 27 - Feb 8): Research and specification study. Reading SysML v2 spec, MCP protocol, tree-sitter docs.

Phase 2 (Feb 9-14): Implementation sprint: grammar development, MCP server, GVSETS paper, converter tool. All 5 repos active simultaneously. 221 commits in 6 days.

Consistency pass (Feb 14): Full traversal protocol plus presentation polish: title renames, tool reconciliation, D3 diagram scaling, narrative strengthening. 34 capstone commits in one day.

Lessons Learned

Technical Surprises

Grammar development was dramatically faster than expected. ~25 hours for 99.6% external coverage vs. an estimate of weeks. Tree-sitter’s declarative grammar.js and test-driven corpus approach turned what we expected to be the critical path into a solved problem within the first sprint.

Automated KEBNF conversion exceeded estimates. 93% automation rate vs 60-70% initial estimate. The converter tool finished in ~12 hours vs 60-100h estimated. The remaining 7% (335+ LR conflicts) is the genuinely hard problem, but the tool eliminated the mechanical work entirely.

Cross-validation caught real divergences. 12 grammar rules where the brute-force grammar diverged from spec intent. Neither path alone would have found these. The dual-path strategy wasn’t just academic; it validated itself by catching errors in both directions.

Process Insights

Implementation-informed reviews produced better artifacts. Conducting SRR and PDR after initial implementation meant requirements were grounded in real constraints, not theoretical. Review findings were immediately actionable because working code existed. The trade-off (scope commitment before formal review) was mitigated by small team and rapid iteration.

The SE/LSE dialectic was genuinely useful. The multi-persona AI workflow (Systems Engineer drafts comprehensively, Lead Systems Engineer prunes pragmatically) produced better INCOSE-aligned artifacts than either approach alone. The deliberate tension forced explicit tailoring rationale for every deviation.

Context engineering is an emerging discipline. The literature search surfaced practitioner work (Manus, OpenViking, mcp-proxy) that was as valuable as academic papers for informing token reduction strategies. The best architectural patterns came from open source implementations, not journals.

What We’d Do Differently

• Start CI container builds from day 1 (R5 risk would have been retired earlier)
• Begin stakeholder validation outreach earlier (Sensmetry, GfSE)
• Establish the estate orchestration pattern before the implementation sprint, not during it

Actual vs. Estimated Effort

lessonsData2 = [
  {label: "Grammar dev", pctOfEst: 25, note: "25h vs weeks"},
  {label: "Converter dev", pctOfEst: 15, note: "12h vs 60-100h"},
  {label: "KEBNF automation", pctOfEst: 143, note: "93% vs 60-70%"},
  {label: "External coverage", pctOfEst: 100, note: "99.6% achieved"},
  {label: "MCP Phase 1", pctOfEst: 60, note: "Done in sprint 2"},
  {label: "Literature search", pctOfEst: 120, note: "18 papers, broader than planned"},
  {label: "Harness development", pctOfEst: 80, note: "Skills, estate, memory patterns"}
]

lessonsChart2 = {
  const w = 1200, h = 816;
  const m = {top: 55, right: 180, bottom: 55, left: 210};
  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, w, h])
    .attr("width", w).attr("height", h)
    .style("font-family", "system-ui, sans-serif");

  const xScale = d3.scaleLinear().domain([0, 160]).range([m.left, w - m.right]);
  const yScale = d3.scaleBand()
    .domain(lessonsData2.map(d => d.label))
    .range([m.top, h - m.bottom]).padding(0.3);

  svg.append("line")
    .attr("x1", xScale(100)).attr("y1", m.top - 14)
    .attr("x2", xScale(100)).attr("y2", h - m.bottom + 8)
    .attr("stroke", "#999").attr("stroke-dasharray", "5,4").attr("stroke-width", 2);
  svg.append("text")
    .attr("x", xScale(100)).attr("y", m.top - 20)
    .attr("text-anchor", "middle").text("100% (estimate)")
    .style("font-size", "15px").style("fill", "#999");

  lessonsData2.forEach(d => {
    const y = yScale(d.label);
    const barColor = d.pctOfEst <= 100 ? "#54A24B" : "#F58518";
    svg.append("rect")
      .attr("x", m.left).attr("y", y)
      .attr("width", xScale(d.pctOfEst) - m.left)
      .attr("height", yScale.bandwidth()).attr("rx", 5)
      .attr("fill", barColor).attr("opacity", 0.5);
    svg.append("text")
      .attr("x", m.left - 10).attr("y", y + yScale.bandwidth() / 2 + 5)
      .attr("text-anchor", "end").text(d.label)
      .style("font-size", "16px").style("fill", "#333");
    svg.append("text")
      .attr("x", xScale(d.pctOfEst) + 8).attr("y", y + yScale.bandwidth() / 2 - 3)
      .text(`${d.pctOfEst}%`).style("font-size", "16px").style("font-weight", "bold")
      .style("fill", barColor);
    svg.append("text")
      .attr("x", xScale(d.pctOfEst) + 8).attr("y", y + yScale.bandwidth() / 2 + 18)
      .text(d.note).style("font-size", "13px").style("fill", "#888");
  });

  svg.append("text").attr("x", (m.left + w - m.right) / 2).attr("y", h - 10)
    .attr("text-anchor", "middle").text("% of Original Estimate")
    .style("font-size", "16px").style("fill", "#666");

  return svg.node();
}

Green bars = completed under estimate. Orange = exceeded estimate (a good thing for automation rate). The dashed line marks the original estimate baseline.

Demo

Content to be determined pending presentation timetable.

Next Steps & Conclusion

Remaining Milestones

Milestone	Date	Action
GVSETS draft	Mar 23	Execute V1/V4/V5 benchmarks, fill metrics
CDR	Mar 29	Critical Design Review with team
Capstone delivery	Apr 25	Final book + all artifacts
GVSETS notification	May 1	Accept/reject
GVSETS final	Jun 5	Camera-ready paper
GVSETS presentation	Aug 11	Conference (Novi, MI)

Deferred Scope (Post-Capstone)

Item	Rationale
HTTP transport	stdio sufficient for evaluation
SysML v2 API integration	Local parsing sufficient (R1)
Container deployment	CI/Linux builds planned
Token reduction Phase 2	6 strategies defined, implementation timeline TBD

Three Publications

Paper	Timeline	Focus
GVSETS 2026	Mar–Jun 2026	MCP architecture + 3-condition benchmark
Grammar Transposition	Q3–Q4 2026	KEBNF-to-tree-sitter methodology (INCOSE/SysEng Journal)
INCOSE 2027	Q3 2027	SE benchmark for LLMs (directed study)

The Thesis, Validated

The capstone demonstrates that structured tooling (grammar-aware parsing, tiered token budgets, validation feedback) transforms LLM interaction with system models from unreliable to practical.

• 7 token reduction strategies defined (1 implemented, 6 in Phase 2 PRD), each sourced from practitioner literature and open source implementations
• Dual-path grammar provides both immediate utility (tree-sitter-sysml) and formal research contribution (kebnf-to-tree-sitter)
• MCP protocol provides the standard interface; SE process ensures defensible foundations
• Infrastructure positions three publications and a directed study (sysml.rs + INCOSE 2027 benchmark)

[1]

D. Jin, Z. Jin, L. Li, Z. Fang, J. Li, and X. Chen, “A System Model Generation Benchmark from Natural Language Requirements.” 2025. Available: https://arxiv.org/abs/2508.03215

[2]

E. Bader, D. Vereno, and C. Neureiter, “Facilitating User-Centric Model-Based Systems Engineering Using Generative AI,” in Proceedings of the 12th international conference on model-based software and systems engineering (MODELSWARD 2024), SCITEPRESS, 2024.

[3]

Y. Bouamra, B. Yun, A. Poisson, and F. Armetta, “SysTemp: A Multi-Agent System for Template-Based Generation of SysML v2.” 2025. Available: https://arxiv.org/abs/2506.21608

[4]

A. Ferrari, S. Abualhaija, and C. Arora, “Model Generation with LLMs: From Requirements to UML Sequence Diagrams,” arXiv preprint, 2024, Available: https://arxiv.org/abs/2404.06371

[5]

Volcengine, OpenViking: Context database for AI agents. (2025). Available: https://github.com/volcengine/OpenViking

[6]

C. Luddy, Xc-mcp: XCode CLI MCP server with progressive disclosure. (2025). Available: https://github.com/conorluddy/xc-mcp

[7]

S. Rodda, Mcp-proxy: Aggregating MCP proxy with progressive tool disclosure. (2025). Available: https://github.com/IAMSamuelRodda/mcp-proxy

[8]

Y. Ji, “Context engineering for AI agents: Lessons from building manus.” Accessed: Feb. 12, 2026. [Online]. Available: https://manus.im/blog/Context-Engineering-for-AI-Agents-Lessons-from-Building-Manus

[9]

S. Yegge, “Welcome to gas town.” Accessed: Feb. 12, 2026. [Online]. Available: https://steve-yegge.medium.com/welcome-to-gas-town-4f25ee16dd04