feat(teams): a team library you own, editable plans, and halves that prove themselves

Teams were something a model invented once per run and threw away. The Teams
page reported on them, which is why it was empty whenever nothing was running.

A team is not a per-run fact. "The backend is Go, it lives under cmd/ and
internal/, go-worker writes it, `go test ./...` proves it" is true of the
repository, forever — and re-deriving it from a 7–32B model each run gets it
subtly wrong often enough to silently downgrade the whole run to one stream.

- pkg/teams: teams are blocks (kind: team), discovered builtin → user → project.
  Six ship. A team carries its globs, its acceptance command, its named seats
  AND an open roster of as many agents and skills as its author wants.
- Preselection is deterministic: query keywords, marker files and extensions,
  scored with no model call. The manager is the fallback, and is still asked for
  the CONTRACT — the one part that is about this request rather than the repo.
- A contract reference that misses by a suffix resolves (`backend` →
  `backend-go`); an ambiguous one is refused rather than guessed.
- Studio: create, edit, duplicate, delete, pin; "Try a request" shows which
  teams a query would get and why; Activate writes the org chart and pins it.
  Teams attach to a pipeline (`teams:`) and to one run (`--team`).
- The approval card now edits everything the harness can apply: task
  description, acceptance, priority and depends_on (ordering is dependencies on
  a wave board), teams added from the library or removed, and the frozen
  contract including renaming a clause without losing its spec.
- The board shows each team, its project manager, what proves its half, and
  cross-team waits; cards carry a team badge and a colour derived from the id.
- The live view pins one line above the stream — agent, task, team, model,
  tokens, and a clock that keeps ticking, because on a local 30B the next log
  line can be four minutes out and silence reads as a hang.
- Each half now RUNS its acceptance command, so green means proved. A command
  that cannot start is UNVERIFIED, never red: failing a team for a missing
  node_modules sends a corrector to rewrite code that was never at fault.

Six defects the live 30B runs surfaced, each pinned by a test:

- a correction ticket on the seam was stamped with whichever half appeared first
  on the board, then denied write access to the other half's files — it sat in
  ready_to_dev for the rest of the run;
- a task's team stamp went stale when its files changed, with the same effect;
- the splitter was never shown the ownership boundaries, so it emitted tasks
  spanning both halves that could never be assigned to either;
- a team's reviewer and tester were editable and never consulted by routing;
- duplicate tester tasks were never folded, and the dedupe ran before file
  reconciliation rewrote the very file sets that define duplication;
- every page except / returned 404 on a browser refresh.

Pages no longer strand themselves in the middle of a large screen: collections
fill the viewport and turn extra width into more columns.

Author: Piotr Laczkowski

CONTRIBUTING.md

@@ -322,6 +322,7 @@ normalize it in `Normalize()` → handle it in `ApplyPatch()` → document it in
 | `pkg/evolve` | fingerprints, repair rules, bandit, reflection, regressions |
 | `pkg/eval`, `pkg/eval/metrics` | eval harness, per-run metrics, `Compare`, replay |
 | `pkg/blocks`, `pkg/pipeline`, `pkg/stacks` | YAML building blocks, phase graph, presets, **language detection** (`DetectPack` / `DetectAll` — the only implementation) |
+| `pkg/teams`, `pkg/squads` | `teams` is the persistent library — a team template plus the evidence that selects it, scored with **no model call**; `squads` is one run's org chart, its ownership rules and its frozen contract |
 | `pkg/permissions`, `pkg/hitl`, `pkg/hooks` | write/shell policy, human gates, lifecycle hooks |
 | `pkg/server` | Studio HTTP/SSE API, security policy, review API |
 | `pkg/cli` | terminal rendering: diffs, gates, REPL input, colour, width, engine-advice translation |

STRUCTURE.md

@@ -22,6 +22,8 @@ slmcode/
 │   ├── memory/ evolve/ eval/    four memory layers; repair rules + bandit; metrics
 │                                 (fed from the tool layer via workspace.ToolObserver)
 │   ├── blocks/ pipeline/ stacks/ YAML building blocks, phase graph, provider presets
+│   ├── teams/ squads/           the team library (deterministic preselection) and
+│                                 one run's org chart, ownership + frozen contract
 │   ├── permissions/ hitl/ hooks/ write & shell policy, human gates, lifecycle hooks
 │   ├── server/                  Studio HTTP/SSE API + security policy
 │   └── cli/                     terminal rendering: diffs, gates, REPL input, width

cmd/slmcode/cmd_block.go

@@ -154,7 +154,7 @@ func blockList(cmd *cobra.Command, args []string) error {
 	cli.Header("Building Blocks")
 
 	groups := map[string][]blocks.CatalogEntry{}
-	kinds := []string{blocks.KindPack, blocks.KindPipeline, blocks.KindAgent, blocks.KindQuality}
+	kinds := []string{blocks.KindPack, blocks.KindPipeline, blocks.KindAgent, blocks.KindQuality, blocks.KindTeam}
 	for _, k := range kinds {
 		groups[k] = nil
 	}
@@ -191,7 +191,7 @@ func blockList(cmd *cobra.Command, args []string) error {
 	fmt.Println(cli.Dim("  New:     slmcode blocks new <kind> <id> --file <path.yaml>"))
 	fmt.Println(cli.Dim("  Edit:    slmcode blocks edit <kind> <id> --file <path.yaml>"))
 	fmt.Println(cli.Dim("  Delete:  slmcode blocks delete <kind> <id>"))
-	fmt.Println(cli.Dim("  Show:    slmcode blocks show <pipeline|agent|quality|pack> <id>"))
+	fmt.Println(cli.Dim("  Show:    slmcode blocks show <pipeline|agent|quality|pack|team> <id>"))
 	fmt.Println(cli.Dim("  Apply:   slmcode blocks apply <pack-id>"))
 	fmt.Println(cli.Dim("  Validate: slmcode blocks validate"))
 	return nil
@@ -210,6 +210,8 @@ func blockShow(kind, id string) error {
 		kind = blocks.KindQuality
 	case "pack", "packs":
 		kind = blocks.KindPack
+	case "team", "teams":
+		kind = blocks.KindTeam
 	}
 
 	root, err := projectRoot()
@@ -289,8 +291,31 @@ func blockShow(kind, id string) error {
 				fmt.Print(string(data))
 			}
 		}
+	case blocks.KindTeam:
+		b, ok := reg.GetTeam(id)
+		if !ok {
+			return fmt.Errorf("team %q not found", id)
+		}
+		printBlockMeta("team:"+b.ID, b.Meta, b.Path)
+		cli.KeyVal("owns", strings.Join(b.Spec.Owns, ", "))
+		cli.KeyVal("acceptance", b.Spec.Acceptance)
+		for label, id := range map[string]string{
+			"worker": b.Spec.Worker, "reviewer": b.Spec.Reviewer,
+			"tester": b.Spec.Tester, "manager": b.Spec.Manager,
+		} {
+			if id != "" {
+				cli.KeyVal(label, id)
+			}
+		}
+		if b.Path != "" {
+			data, err := os.ReadFile(b.Path)
+			if err == nil {
+				fmt.Println()
+				fmt.Print(string(data))
+			}
+		}
 	default:
-		return fmt.Errorf("unknown block kind %q (use: pipeline, agent, quality, pack)", kind)
+		return fmt.Errorf("unknown block kind %q (use: pipeline, agent, quality, pack, team)", kind)
 	}
 	return nil
 }
@@ -451,7 +476,7 @@ func blockValidate() error {
 func blockNew(kind, id, filePath, name string) error {
 	kind = blocks.NormalizeKind(kind)
 	if kind == "" {
-		return fmt.Errorf("unknown block kind %q (use: pipeline, agent, quality, pack)", kind)
+		return fmt.Errorf("unknown block kind %q (use: pipeline, agent, quality, pack, team)", kind)
 	}
 	id = strings.ToLower(strings.TrimSpace(id))
 	if filePath == "" && name == "" {
@@ -499,7 +524,7 @@ func blockNew(kind, id, filePath, name string) error {
 func blockEdit(kind, id, filePath string) error {
 	kind = blocks.NormalizeKind(kind)
 	if kind == "" {
-		return fmt.Errorf("unknown block kind %q (use: pipeline, agent, quality, pack)", kind)
+		return fmt.Errorf("unknown block kind %q (use: pipeline, agent, quality, pack, team)", kind)
 	}
 	id = strings.ToLower(strings.TrimSpace(id))
 	if filePath == "" {
@@ -549,7 +574,7 @@ func blockEdit(kind, id, filePath string) error {
 func blockDelete(kind, id string) error {
 	kind = blocks.NormalizeKind(kind)
 	if kind == "" {
-		return fmt.Errorf("unknown block kind %q (use: pipeline, agent, quality, pack)", kind)
+		return fmt.Errorf("unknown block kind %q (use: pipeline, agent, quality, pack, team)", kind)
 	}
 	id = strings.ToLower(strings.TrimSpace(id))
 

cmd/slmcode/cmd_core.go

@@ -227,6 +227,7 @@ func runCmd() *cobra.Command {
 			mode, _ := cmd.Flags().GetString("mode")
 			agent, _ := cmd.Flags().GetString("agent")
 			pinSkills, _ := cmd.Flags().GetStringSlice("skill")
+			pinTeams, _ := cmd.Flags().GetStringSlice("team")
 			dynamic, _ := cmd.Flags().GetBool("dynamic")
 			noDynamic, _ := cmd.Flags().GetBool("no-dynamic")
 			if mode != "" {
@@ -247,6 +248,12 @@ func runCmd() *cobra.Command {
 					query += " @skill:" + s
 				}
 			}
+			// An explicit team choice is an instruction, not a hypothesis: it
+			// is used regardless of what the query text and the workspace
+			// would otherwise have scored.
+			if len(pinTeams) > 0 {
+				h.Config.Teams = append(append([]string{}, h.Config.Teams...), pinTeams...)
+			}
 
 			// Pre-flight #1, and it costs nothing: resolve every human-in-the-
 			// loop gate BEFORE the first model call. A headless run whose gate
@@ -387,6 +394,7 @@ func runCmd() *cobra.Command {
 	cmd.Flags().Bool("dynamic", false, "run the composer specialist to assemble a task-specific pipeline (default: on)")
 	cmd.Flags().Bool("no-dynamic", false, "disable the dynamic pipeline (use the static pipeline)")
 	cmd.Flags().StringSlice("skill", nil, "pin/load skill by name (repeatable); also accepts @skill:name in query")
+	cmd.Flags().StringSlice("team", nil, "run with this team from the library, whatever the query says (repeatable); see `slmcode block list --kind team`")
 	registerDeliveryFlags(cmd)
 	registerIsolationFlags(cmd)
 	return cmd

docs/blocks.md

@@ -13,22 +13,23 @@
 
 ## What are Building Blocks?
 
-Blocks are **versioned, marketplace-ready YAML packages** that define reusable configurations for the SLMCode pipeline. They come in four kinds:
+Blocks are **versioned, marketplace-ready YAML packages** that define reusable configurations for the SLMCode pipeline. They come in five kinds:
 
 | Kind | Schema | Purpose |
 |------|--------|---------|
 | `pipeline` | `PipelineBlock` | Phase graph, loop agents, insertable slots |
 | `agent` | `AgentBlock` | Custom specialist definition or builtin override |
 | `quality` | `QualityBlock` | Format/lint/test/build commands per language |
 | `pack` | `PackBlock` | Composes pipeline + quality + agents + skills |
+| `team` | `TeamBlock` | A virtual dev team: what it owns, what proves it, who staffs it — see [Teams](squads.md#the-team-library) |
 
 ---
 
 ## Discovery Order
 
 Blocks are discovered in a priority chain. **First ID wins per kind:**
 
-1. **Project** — `.slmcode/blocks/{pipelines,agents,quality,packs}/*.yaml`
+1. **Project** — `.slmcode/blocks/{pipelines,agents,quality,packs,teams}/*.yaml`
 2. **User** — `~/.slmcode/blocks/…` or `$XDG_CONFIG_HOME/slmcode/blocks/…`
 3. **Extra** — `$SLMCODE_BLOCKS` env var, walk-up `blocks/` dirs
 4. **Builtin** — embedded in `pkg/blocks/bundled/` (compiled into binary)
@@ -43,7 +44,7 @@ Every block YAML file shares this header:
 
 ```yaml
 api_version: blocks/v1    # required — current schema version
-kind: pipeline            # pipeline | agent | quality | pack
+kind: pipeline            # pipeline | agent | quality | pack | team
 id: my-block              # lowercase kebab-case, 2-64 chars, [a-z][a-z0-9_-]+
 name: My Block            # human-readable display name
 description: A reusable block