feat(02-02): capture named sessions through a loopback proxy

Record Nuxt/MCP traffic as ordered flows via parity:proxy, pin
loopback upstream, and refuse oversized or credential-shaped fixtures.

Co-authored-by: Cursor <cursoragent@cursor.com>

cmd/summer/main.go

@@ -29,6 +29,7 @@ func toolCommands() []bonfire.Command {
 		makePluginCommand(),
 		addPluginCommand(),
 		devCommand(),
+		parityProxyCommand(),
 		parityRecordCommand(),
 		parityReplayCommand(),
 	}

cmd/summer/parity.go

@@ -9,6 +9,22 @@ import (
 	"git.golem15.com/golem15/summercms/tide"
 )
 
+func parityProxyCommand() bonfire.Command {
+	return bonfire.Command{
+		Name:        "parity:proxy",
+		Description: "Record named HTTP sessions through a loopback reverse proxy",
+		Flags: []bonfire.Flag{
+			{Name: "listen", Description: "Loopback bind address", Default: tide.DefaultListen},
+			{Name: "upstream", Description: "Fixed loopback HTTP origin", Default: tide.DefaultUpstream},
+			{Name: "session", Description: "Default session name when X-Parity-Session is absent"},
+			{Name: "rules", Description: "Committed YAML capture rules"},
+			{Name: "vars", Description: "Private mode-0600 variable store outside fixtures"},
+			{Name: "fixtures", Description: "Directory for nuxt/ and mcp/ session flows"},
+		},
+		Run: runParityProxy,
+	}
+}
+
 func parityRecordCommand() bonfire.Command {
 	return bonfire.Command{
 		Name:        "parity:record",
@@ -34,6 +50,38 @@ func parityReplayCommand() bonfire.Command {
 	}
 }
 
+func runParityProxy(ctx context.Context, in bonfire.Input, out bonfire.Output) error {
+	rulesPath, err := requireFlag(in, "rules", "parity:proxy")
+	if err != nil {
+		return err
+	}
+	fixtures, err := requireFlag(in, "fixtures", "parity:proxy")
+	if err != nil {
+		return err
+	}
+	rules, err := tide.LoadRules(rulesPath)
+	if err != nil {
+		return err
+	}
+	listen, _ := in.Flag("listen")
+	upstream, _ := in.Flag("upstream")
+	session, _ := in.Flag("session")
+	varsPath, _ := in.Flag("vars")
+	proxy, err := tide.NewProxy(tide.ProxyConfig{
+		Listen:   listen,
+		Upstream: upstream,
+		Session:  session,
+		Rules:    rules,
+		VarsPath: varsPath,
+		Fixtures: fixtures,
+	})
+	if err != nil {
+		return err
+	}
+	out.Info(fmt.Sprintf("proxy listening on %s → %s", listen, upstream))
+	return proxy.ListenAndServe(ctx)
+}
+
 func runParityRecord(ctx context.Context, in bonfire.Input, out bonfire.Output) error {
 	specPath, err := requireFlag(in, "spec", "parity:record")
 	if err != nil {

cmd/summer/parity_test.go

@@ -14,7 +14,7 @@ import (
 
 func TestParityCommands(t *testing.T) {
 	names := commandNames()
-	for _, want := range []string{"parity:record", "parity:replay"} {
+	for _, want := range []string{"parity:record", "parity:replay", "parity:proxy"} {
 		if !containsName(names, want) {
 			t.Fatalf("missing %s in %v", want, names)
 		}
@@ -99,6 +99,23 @@ func TestParityCommands(t *testing.T) {
 	if err := runParity("parity:replay", "--fixtures", keyFixture, "--target", keyOrder.URL); err != nil {
 		t.Fatalf("reordered JSON keys must pass: %v", err)
 	}
+
+	err = runParity("parity:proxy")
+	if err == nil || !strings.Contains(err.Error(), "--rules") {
+		t.Fatalf("proxy without rules: %v", err)
+	}
+	rulesPath := filepath.Join(outDir, "rules.yaml")
+	if err := os.WriteFile(rulesPath, []byte("client: nuxt\nkeep_request_headers: []\nkeep_response_headers: []\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	err = runParity("parity:proxy", "--rules", rulesPath, "--fixtures", outDir, "--upstream", "http://example.com")
+	if err == nil || !strings.Contains(err.Error(), "loopback") {
+		t.Fatalf("proxy non-loopback upstream: %v", err)
+	}
+	err = runParity("parity:proxy", "--rules", rulesPath, "--fixtures", outDir, "--listen", "0.0.0.0:8422")
+	if err == nil || !strings.Contains(err.Error(), "loopback") {
+		t.Fatalf("proxy non-loopback listen: %v", err)
+	}
 }
 
 func commandNames() []string {