chore: prepare v0.1.0 OSS release

- Add MIT LICENSE file - Update version to 0.1.0 - Add mol-version-bump molecule for release workflow - Terse README for OSS release 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-20 22:22:42 -08:00
parent b70dc21826
commit 2a0f1fe514
5 changed files with 167 additions and 116 deletions
--- a/21
+++ b/21
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Steve Yegge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/README.md
+++ b/README.md
@@ -1,43 +1,26 @@
 # Gas Town

-**Enterprise-grade cognitive processing for AI agent swarms.**
+Multi-agent workspace manager for AI coding agents.

-Gas Town is a multi-agent workspace manager that coordinates AI coding agents working on software projects. It provides the infrastructure for spawning workers, processing work through structured workflows (molecules), and coordinating agents through a unified data plane (Beads).
+Gas Town coordinates swarms of AI agents working on software projects. Workers (polecats) implement features and fix bugs. Refineries review and merge code. Witnesses manage worker lifecycles. Mayors coordinate across projects.

-## The Idea
+## Install

-Traditional AI coding assistants help you write code. Gas Town **writes code for you**.
-
-Instead of AI as autocomplete, Gas Town treats AI agents as workers:
- **Polecats** implement features and fix bugs
- **Refineries** review and merge code
- **Witnesses** manage worker lifecycle
- **Mayors** coordinate across projects
-
-Work flows through **molecules** - structured workflow templates that encode quality gates, dependencies, and recovery checkpoints. Any worker can continue any workflow from where another left off.
-
-## Key Features
-
- **Nondeterministic Idempotence**: Workflows survive crashes, context compaction, and agent restarts
- **Molecule-Based Quality**: Structured workflows with built-in gates, not prompt-based instructions
- **Unified Data Plane**: All state in Beads (issues, messages, workflows) - queryable, auditable, persistent
- **Hierarchical Coordination**: Mayor → Witness → Refinery → Polecat chain of command
- **Federation Ready**: Multiple rigs across machines, coordinated through Beads sync
+```bash
+go install github.com/steveyegge/gastown/cmd/gt@latest
+```

 ## Quick Start

 ```bash
-# Install
-go install github.com/steveyegge/gastown/cmd/gt@latest
-
 # Create a town (workspace)
-gt install ~/gt --git
+gt install ~/gt

-# Add a rig for your project
+# Add a project rig
 gt rig add myproject --remote=https://github.com/you/myproject.git

-# Spawn a polecat to work on an issue
-gt spawn --issue myproject-123 --molecule mol-engineer-in-box
+# Spawn a worker on an issue
+gt spawn --issue myproject-123
 ```

 ## Architecture
@@ -45,113 +28,40 @@ gt spawn --issue myproject-123 --molecule mol-engineer-in-box
 ```
 Town (~/gt/)
 ├── Mayor (global coordinator)
-├── Rig: project-alpha
-│   ├── Witness (lifecycle manager)
-│   ├── Refinery (merge queue)
-│   └── Polecats (workers)
-│       ├── furiosa/
-│       ├── nux/
-│       └── slit/
-└── Rig: project-beta
-    └── ...
+└── Rig: myproject
+    ├── Witness (lifecycle manager)
+    ├── Refinery (merge queue)
+    └── Polecats (workers)
 ```

-See [docs/architecture.md](docs/architecture.md) for comprehensive documentation.
+## Key Concepts

-## Molecules
-
-Molecules are structured workflow templates:
-
-```markdown
-## Molecule: engineer-in-box
-Full workflow from design to merge.
-
-## Step: design
-Think carefully about architecture.
-Write a brief design summary.
-
-## Step: implement
-Write the code. Follow codebase conventions.
-Needs: design
-
-## Step: test
-Write and run tests. Cover edge cases.
-Needs: implement
-
-## Step: submit
-Submit for merge via refinery.
-Needs: test
-```
-
-Built-in molecules:
- `mol-engineer-in-box` - Full quality workflow (design → implement → review → test → submit)
- `mol-quick-fix` - Fast path for small changes (implement → test → submit)
- `mol-research` - Exploration workflow (investigate → document)
-
-## Beads
-
-Gas Town uses [Beads](https://github.com/steveyegge/beads) for issue tracking and coordination:
-
-```bash
-bd ready              # Show work ready to start
-bd list --status=open # All open issues
-bd show gt-123        # Issue details
-bd create --title="Fix auth bug" --type=bug
-bd close gt-123       # Mark complete
-```
+- **Molecules**: Structured workflow templates with quality gates and dependencies
+- **Beads**: Unified data plane for issues, messages, and state ([github.com/steveyegge/beads](https://github.com/steveyegge/beads))
+- **Nondeterministic Idempotence**: Workflows survive crashes and agent restarts

 ## Commands

 ```bash
-# Town management
-gt install <path>     # Create new town
-gt status             # Overall status
-gt doctor             # Diagnose issues
-
-# Rig management
-gt rig add <name>     # Add project rig
+gt status             # Town status
 gt rig list           # List rigs
-
-# Worker management
-gt spawn --issue <id> # Start polecat on issue
-gt polecat list <rig> # List polecats
-
-# Communication
+gt spawn --issue <id> # Start worker
 gt mail inbox         # Check messages
-gt mail send <addr>   # Send message
 ```

-## Status
-
-**Work in Progress** - This is the Go rewrite of the Python gastown tool.
-
-See [gastown-py](https://github.com/steveyegge/gastown-py) for the Python version.
-
 ## Documentation

- [Architecture](docs/architecture.md) - System design and concepts
- [Vision](docs/vision.md) - Where Gas Town is going
- [Federation](docs/federation-design.md) - Multi-machine coordination
- [Merge Queue](docs/merge-queue-design.md) - Refinery and integration
+- [Architecture](docs/architecture.md)
+- [Molecules](docs/molecules.md)
+- [Federation](docs/federation-design.md)

 ## Development

 ```bash
-# Build
 go build -o gt ./cmd/gt
-
-# Test
 go test ./...
-
-# Install locally
-go install ./cmd/gt
 ```

-## Related
-
- [beads](https://github.com/steveyegge/beads) - Issue tracking for AI agents
- [gastown-py](https://github.com/steveyegge/gastown-py) - Python version (reference)
-
 ## License

 MIT
--- a/internal/beads/builtin_molecules.go
+++ b/internal/beads/builtin_molecules.go
@@ -17,6 +17,7 @@ func BuiltinMolecules() []BuiltinMolecule {
 		InstallGoBinaryMolecule(),
 		BootstrapGasTownMolecule(),
 		PolecatWorkMolecule(),
+		VersionBumpMolecule(),
 	}
 }

@@ -391,6 +392,125 @@ Needs: update-handoff`,
 	}
 }

+// VersionBumpMolecule returns the version-bump molecule definition.
+// This is the release checklist for Gas Town versions.
+func VersionBumpMolecule() BuiltinMolecule {
+	return BuiltinMolecule{
+		ID:    "mol-version-bump",
+		Title: "Version Bump",
+		Description: `Release checklist for Gas Town version {{version}}.
+
+This molecule ensures all release steps are completed properly.
+Replace {{version}} with the target version (e.g., 0.1.0).
+
+## Step: update-version
+Update version string in internal/cmd/version.go.
+
+Change the Version variable to the new version:
+` + "```" + `go
+var (
+    Version   = "{{version}}"
+    BuildTime = "unknown"
+    GitCommit = "unknown"
+)
+` + "```" + `
+
+## Step: rebuild-binary
+Rebuild the gt binary with version info.
+
+` + "```" + `bash
+go build -ldflags="-X github.com/steveyegge/gastown/internal/cmd.Version={{version}} \
+  -X github.com/steveyegge/gastown/internal/cmd.GitCommit=$(git rev-parse --short HEAD) \
+  -X github.com/steveyegge/gastown/internal/cmd.BuildTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  -o gt ./cmd/gt
+` + "```" + `
+
+Verify the version:
+` + "```" + `bash
+./gt version
+` + "```" + `
+
+Needs: update-version
+
+## Step: run-tests
+Run the full test suite.
+
+` + "```" + `bash
+go test ./...
+` + "```" + `
+
+Fix any failures before proceeding.
+Needs: rebuild-binary
+
+## Step: update-changelog
+Update CHANGELOG.md with release notes.
+
+Add a new section at the top:
+` + "```" + `markdown
+## [{{version}}] - YYYY-MM-DD
+
+### Added
+- Feature descriptions
+
+### Changed
+- Change descriptions
+
+### Fixed
+- Bug fix descriptions
+` + "```" + `
+
+Needs: run-tests
+
+## Step: commit-release
+Commit the release changes.
+
+` + "```" + `bash
+git add -A
+git commit -m "release: v{{version}}"
+` + "```" + `
+
+Needs: update-changelog
+
+## Step: tag-release
+Create and push the release tag.
+
+` + "```" + `bash
+git tag -a v{{version}} -m "Release v{{version}}"
+git push origin main
+git push origin v{{version}}
+` + "```" + `
+
+Needs: commit-release
+
+## Step: verify-release
+Verify the release is complete.
+
+- Check that the tag exists on GitHub
+- Verify CI/CD (if configured) completed successfully
+- Test installation from the new tag:
+` + "```" + `bash
+go install github.com/steveyegge/gastown/cmd/gt@v{{version}}
+gt version
+` + "```" + `
+
+Needs: tag-release
+
+## Step: update-installations
+Update local installations and restart daemons.
+
+` + "```" + `bash
+# Rebuild and install
+go install ./cmd/gt
+
+# Restart any running daemons
+pkill -f "gt daemon" || true
+gt daemon start
+` + "```" + `
+
+Needs: verify-release`,
+	}
+}
+
 // SeedBuiltinMolecules creates all built-in molecules in the beads database.
 // It skips molecules that already exist (by title match).
 // Returns the number of molecules created.
--- a/internal/beads/builtin_molecules_test.go
+++ b/internal/beads/builtin_molecules_test.go
@@ -5,8 +5,8 @@ import "testing"
 func TestBuiltinMolecules(t *testing.T) {
 	molecules := BuiltinMolecules()

-	if len(molecules) != 6 {
-		t.Errorf("expected 6 built-in molecules, got %d", len(molecules))
+	if len(molecules) != 7 {
+		t.Errorf("expected 7 built-in molecules, got %d", len(molecules))
 	}

 	// Verify each molecule can be parsed and validated
--- a/internal/cmd/version.go
+++ b/internal/cmd/version.go
@@ -9,7 +9,7 @@ import (

 // Version information - set at build time via ldflags
 var (
-	Version   = "0.0.1"
+	Version   = "0.1.0"
 	BuildTime = "unknown"
 	GitCommit = "unknown"
 )