@baselane/packs 0.1.0

package/packs/frontend-taste/rendered/AGENTS.md

@@ -0,0 +1,68 @@
+# AGENTS.md
+
+<!-- generated from workflow-pack frontend-taste v1.2.0 -->
+
+## Frontend taste discipline
+
+Adopt these as fixed defaults, not options to tune per project — their whole value is removing the per-page style debate, the way a formatter removes the whitespace debate. Brand color and corner radius are the only inputs; everything below is settled.
+
+### The three locks
+
+Decide these once per page and hold them for the whole page — mixing them is the single biggest tell of unreviewed AI output:
+
+1. **One accent color.** Pick a single accent for interactive/emphasis elements. Everything else is neutrals.
+2. **One corner-radius system.** Pick a radius scale (e.g. sm/md/lg mapped to fixed px values) and use it everywhere — no ad-hoc `rounded-[7px]` next to `rounded-2xl`.
+3. **One theme mode, decided at the page level.** Don't let individual components guess light/dark independently.
+
+### Hero discipline
+
+- Headline is 2 lines or fewer. If it doesn't fit, the message is too long, not the font too small.
+- Subtext is roughly 20 words or fewer — one sentence, not a paragraph.
+- Nav height is capped (~64px); it should never compete with the hero for vertical space.
+
+### Anti-slop bans
+
+These patterns are default outputs of ungrounded AI generation. Treat every one as a defect, not a style choice:
+
+- No three-equal-width feature card rows. Use asymmetric layouts — different widths, different emphasis — so the page doesn't read as a template.
+- No AI-purple/mesh-blob gradients unless the brand explicitly calls for them.
+- No section-number eyebrows like "001 · Features" — they signal filler, not information.
+- No `window.addEventListener('scroll')` for reveal/parallax effects — use `IntersectionObserver`, it's cheaper and doesn't jank.
+- No emoji as section markers or bullet icons.
+- Neutrals get a deliberate hue bias (warm or cool grey); never pure mid-grey (`#808080`-style), which reads as unstyled.
+
+### Type
+
+- Pair a display face and a body face deliberately — don't ship the framework default pairing unreviewed.
+- Set a type scale (a small fixed set of sizes) and hold it; don't invent one-off sizes per component.
+
+### Both themes
+
+Design light and dark as two considered modes, not one inverted into the other — check contrast and accent legibility in both.
+
+## Harness capabilities
+
+- design · repo · author — provisioned
+
+### Design
+
+Follow `DESIGN.md` for all UI and visual work — it is the source of truth for color, type, spacing, and component conventions in this project.
+
+## Workflow pack: Frontend taste
+
+Ends the per-component style debate with fixed, non-configurable defaults: three hard locks per page, disciplined heroes, and a banned-AI-slop checklist enforced before merge.
+
+### Roles
+
+- **taste-reviewer** — Reviews a built UI against the three locks and anti-slop bans, reporting concrete violations with file:line. Use after building or changing any landing/marketing UI, before calling it done.
+
+### Commands
+
+- **/design-review** `[optional: path or component name]` — Run the taste-reviewer over the current changes and summarize violations and fixes.
+  - How it runs: Invoke the taste-reviewer subagent over the current diff (or $ARGUMENTS if given). Present its findings grouped by rule (locks, hero discipline, anti-slop bans), each with file:line and fix. If it finds nothing, report a clean pass.
+
+### Guardrails
+
+- Nudge the three locks whenever UI files are touched.
+
+Tool-specific implementations live alongside this file (see `CLAUDE.md` for the Claude Code implementation). Tools without a native subagent/command surface should treat the sections above as operating instructions.

package/packs/frontend-taste/rendered/CLAUDE.md

@@ -0,0 +1,8 @@
+# CLAUDE.md
+
+@AGENTS.md
+
+This project defines a native Claude Code implementation of this workflow pack:
+- Subagent: `.claude/agents/taste-reviewer.md`
+- Command: `.claude/commands/design-review.md`
+- Hooks: see `.claude/settings.json`

package/packs/frontend-taste/rendered/DESIGN.md

@@ -0,0 +1,72 @@
+## Visual theme & atmosphere
+
+Mood: distinctive, non-generic, considered. The brand color (#4F46E5) is the single accent — everything else in the interface is neutral, so the accent stays legible and the page never competes with itself.
+
+Design light and dark as two considered modes, not one inverted into the other.
+
+## Color palette & roles
+
+| Token | Value | Role |
+| --- | --- | --- |
+| `--color-brand` | #4F46E5 | Accent — interactive elements, emphasis, focus rings |
+| `--color-neutral-50` | #F9F9FA | Background / surface |
+| `--color-neutral-100` | #EEEEF1 | Background / surface |
+| `--color-neutral-300` | #CDCDD6 | Border / muted |
+| `--color-neutral-500` | #8A899F | Border / muted |
+| `--color-neutral-700` | #4A495A | Text |
+| `--color-neutral-900` | #212027 | Text |
+| `--color-ok` | #16A34A | Success / positive state |
+| `--color-warn` | #D97706 | Warning / caution state |
+
+Exactly one accent color exists in this palette. Do not introduce a second accent for "variety" — differentiate with weight, size, and spacing instead.
+
+## Typography
+
+- Display face: **Inter** — headings, hero copy, anything meant to lead the eye.
+- Body face: **Inter** — paragraph text, labels, UI chrome.
+- Type scale (px): 12 / 14 / 16 / 20 / 24 / 32 / 48. Pick from this set; don't invent one-off sizes.
+- Line height: 1.2 for display sizes (20px+), 1.5 for body sizes (12-16px).
+
+## Component stylings
+
+- Radius scale (px): sm 4 · md 8 · lg 16 · full 9999. One scale, used everywhere — no ad-hoc radii next to the standard ones.
+- Buttons: `md` radius, brand-colored fill for primary, neutral border for secondary, no gradient fills.
+- Inputs: `sm` radius, neutral-300 border at rest, brand-colored border + ring on focus.
+- Cards: `lg` radius, neutral-100 background, neutral-300 border (prefer a border over a shadow in light mode).
+
+## Layout & spacing
+
+- Spacing scale (px, 4px base grid): 4 / 8 / 12 / 16 / 24 / 32 / 48 / 64.
+- Container max-width: 1200px, centered, with 24px gutters on mobile.
+- Prefer asymmetric layouts — mixed widths, deliberate emphasis — over evenly divided grids; a row of three equal-width cards is the single biggest tell of an unreviewed template.
+
+## Depth & elevation
+
+- Shadow scale: `sm` for hover states, `md` for popovers/dropdowns, `lg` for modals only.
+- Elevate sparingly — most surfaces should read as flat with a border, not lifted with a shadow.
+- z-index layers: base 0, sticky 10, dropdown 20, modal 30, toast 40. Don't invent values outside this set.
+
+## Do's and don'ts
+
+**Do**
+- Hold one accent color for the whole page.
+- Hold one radius system for the whole page.
+- Give neutrals a deliberate hue bias.
+- Decide light/dark at the page level, not per component.
+
+**Don't**
+- No second accent color, however small the use.
+- No three-equal-width card rows — it's the default output of ungrounded generation.
+- No AI-purple/mesh-blob gradients unless the brand explicitly calls for them.
+- No pure mid-grey (`#808080`-style) neutrals — always hue-biased.
+- No section-number eyebrows ("001 · Features") — they signal filler, not information.
+
+## Responsive behavior
+
+- Breakpoints (px): 640 / 768 / 1024 / 1280. Design mobile-first; add complexity as width increases.
+- Minimum touch target: 44x44px on any interactive element below the 768px breakpoint.
+- Nav collapses to a single control below 768px; it never competes with the hero for vertical space.
+
+## Agent prompt guide
+
+Any AI tool generating or modifying UI in this repository must follow this file as the source of truth for color, type, spacing, radius, and elevation. When a decision isn't covered here, match the closest existing pattern rather than inventing a new one — and if a new durable decision gets made, update this file so the next session inherits it too.

package/packs/frontend-taste/rendered/GEMINI.md

@@ -0,0 +1,3 @@
+# GEMINI.md
+
+@AGENTS.md

package/packs/go-rules/pack.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://baselane.dev/schema/workflow-pack-v1.json",
+  "id": "go-rules",
+  "version": "1.3.0",
+  "title": "Go rules",
+  "summary": "Go conventions a linter can't check — interfaces accepted not returned, errors wrapped with context, functional options, owned shared state — with a reviewer and a gofmt guard; formatting, vet, and races belong in CI.",
+  "scope": "repo",
+  "attribution": { "source": "affaan-m/ECC", "url": "https://github.com/affaan-m/ECC", "license": "MIT" },
+  "context": {
+    "markdown": "## Go conventions (beyond what the linter enforces)\n\n`gofmt`, `goimports`, and `go vet` already catch formatting and the obvious mistakes — this pack is the judgment they can't encode. Keep the mechanical checks in CI (`gofmt -l .`, `go vet ./...`, `go test -race ./...`, `gosec ./...`); the reviewer covers the rest.\n\n### API shape\n\n- Accept interfaces, return structs. Define an interface where it is consumed (1-3 methods), never next to the implementation.\n- Use functional options (`type Option func(*Server)`) for constructors with many optional parameters, not a giant config struct or a long positional list.\n- Inject dependencies through constructors (`NewUserService(repo, logger)`), never package-level globals.\n\n### Errors\n\n- Wrap every propagated error with context and `%w` (`fmt.Errorf(\"create user: %w\", err)`). A bare returned `err` with no origin is a defect, not a shortcut.\n\n### Concurrency\n\n- Thread `context.Context` through call chains for cancellation and timeout (`ctx, cancel := context.WithTimeout(ctx, 5*time.Second)`; `defer cancel()`).\n- Every piece of shared state has an explicit owner — a mutex or a channel — or a comment proving why it is safe. \"Probably fine\" is a race.\n\n### Boundaries\n\n- Validate external input at the boundary before it reaches business logic; fail fast with a clear message.\n- Read required secrets from the environment and `log.Fatal` on an empty value at startup — never a silent zero value.\n\n### Flag in review (a linter won't)\n\n- A propagated error with no `%w` and no context string.\n- An interface defined beside its implementation instead of its consumer.\n- Shared state touched by multiple goroutines with no mutex/channel and no safety comment.\n- A required env var read without an empty-check before use.\n"
+  },
+  "agents": [
+    {
+      "name": "go-reviewer",
+      "description": "Reviews changed Go against the Go standards: interfaces, wrapped errors, context threading, race safety, and env-var secrets. Reports file:line + severity. Use after any Go change.",
+      "tools": ["Read", "Grep", "Glob", "Bash"],
+      "model": "sonnet",
+      "prompt": "You are a Go reviewer. Read the changed Go files and check them against the conventions in context: small consumer-defined interfaces, errors wrapped with `%w` and context, functional options, dependency injection through constructors, context threading, explicitly owned shared state, boundary input validation, and env-var secrets that fail fast. Formatting, `go vet`, and races are the linter/CI's job — don't re-litigate them. Cite the exact file:line for each finding, name the concrete failure mode, and give severity. If the change is sound, say so plainly rather than inventing findings."
+    }
+  ],
+  "commands": [
+    {
+      "name": "go-review",
+      "description": "Run the Go reviewer over the current change against this pack's Go standards.",
+      "argument_hint": "[base ref]",
+      "prompt": "Invoke the go-reviewer subagent on the changed Go files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — consumer-defined interfaces, errors wrapped with %w and context, functional options, context threading, explicitly owned shared state, boundary validation, and fail-fast env-var secrets — and reports file:line + severity. Formatting, go vet, and races are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging."
+    }
+  ],
+  "hooks": [
+    {
+      "event": "PostToolUse",
+      "matcher": "Edit|Write",
+      "description": "After an edit, check Go formatting with gofmt when it is installed.",
+      "action": "run-command",
+      "command": "if command -v gofmt >/dev/null 2>&1; then gofmt -l .; else echo \"gofmt not found — install the Go toolchain to check formatting (go-rules)\"; fi"
+    }
+  ]
+}

package/packs/go-rules/rendered/.claude/agents/go-reviewer.md

@@ -0,0 +1,8 @@
+---
+name: go-reviewer
+description: Reviews changed Go against the Go standards: interfaces, wrapped errors, context threading, race safety, and env-var secrets. Reports file:line + severity. Use after any Go change.
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+You are a Go reviewer. Read the changed Go files and check them against the conventions in context: small consumer-defined interfaces, errors wrapped with `%w` and context, functional options, dependency injection through constructors, context threading, explicitly owned shared state, boundary input validation, and env-var secrets that fail fast. Formatting, `go vet`, and races are the linter/CI's job — don't re-litigate them. Cite the exact file:line for each finding, name the concrete failure mode, and give severity. If the change is sound, say so plainly rather than inventing findings.

package/packs/go-rules/rendered/.claude/commands/go-review.md

@@ -0,0 +1,6 @@
+---
+description: Run the Go reviewer over the current change against this pack's Go standards.
+argument-hint: [base ref]
+---
+
+Invoke the go-reviewer subagent on the changed Go files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — consumer-defined interfaces, errors wrapped with %w and context, functional options, context threading, explicitly owned shared state, boundary validation, and fail-fast env-var secrets — and reports file:line + severity. Formatting, go vet, and races are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging.

package/packs/go-rules/rendered/.claude/settings.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if command -v gofmt >/dev/null 2>&1; then gofmt -l .; else echo \"gofmt not found — install the Go toolchain to check formatting (go-rules)\"; fi"
+          }
+        ]
+      }
+    ]
+  }
+}

package/packs/go-rules/rendered/.github/copilot-instructions.md

@@ -0,0 +1,44 @@
+# Copilot instructions
+
+## Go conventions (beyond what the linter enforces)
+
+`gofmt`, `goimports`, and `go vet` already catch formatting and the obvious mistakes — this pack is the judgment they can't encode. Keep the mechanical checks in CI (`gofmt -l .`, `go vet ./...`, `go test -race ./...`, `gosec ./...`); the reviewer covers the rest.
+
+### API shape
+
+- Accept interfaces, return structs. Define an interface where it is consumed (1-3 methods), never next to the implementation.
+- Use functional options (`type Option func(*Server)`) for constructors with many optional parameters, not a giant config struct or a long positional list.
+- Inject dependencies through constructors (`NewUserService(repo, logger)`), never package-level globals.
+
+### Errors
+
+- Wrap every propagated error with context and `%w` (`fmt.Errorf("create user: %w", err)`). A bare returned `err` with no origin is a defect, not a shortcut.
+
+### Concurrency
+
+- Thread `context.Context` through call chains for cancellation and timeout (`ctx, cancel := context.WithTimeout(ctx, 5*time.Second)`; `defer cancel()`).
+- Every piece of shared state has an explicit owner — a mutex or a channel — or a comment proving why it is safe. "Probably fine" is a race.
+
+### Boundaries
+
+- Validate external input at the boundary before it reaches business logic; fail fast with a clear message.
+- Read required secrets from the environment and `log.Fatal` on an empty value at startup — never a silent zero value.
+
+### Flag in review (a linter won't)
+
+- A propagated error with no `%w` and no context string.
+- An interface defined beside its implementation instead of its consumer.
+- Shared state touched by multiple goroutines with no mutex/channel and no safety comment.
+- A required env var read without an empty-check before use.
+
+## Workflow pack: Go rules
+
+Go conventions a linter can't check — interfaces accepted not returned, errors wrapped with context, functional options, owned shared state — with a reviewer and a gofmt guard; formatting, vet, and races belong in CI.
+
+When acting as the go-reviewer role: You are a Go reviewer. Read the changed Go files and check them against the conventions in context: small consumer-defined interfaces, errors wrapped with `%w` and context, functional options, dependency injection through constructors, context threading, explicitly owned shared state, boundary input validation, and env-var secrets that fail fast. Formatting, `go vet`, and races are the linter/CI's job — don't re-litigate them. Cite the exact file:line for each finding, name the concrete failure mode, and give severity. If the change is sound, say so plainly rather than inventing findings.
+
+Workflow steps:
+
+- go-review: Invoke the go-reviewer subagent on the changed Go files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — consumer-defined interfaces, errors wrapped with %w and context, functional options, context threading, explicitly owned shared state, boundary validation, and fail-fast env-var secrets — and reports file:line + severity. Formatting, go vet, and races are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging.
+
+- After an edit, check Go formatting with gofmt when it is installed.

package/packs/go-rules/rendered/AGENTS.md

@@ -0,0 +1,54 @@
+# AGENTS.md
+
+<!-- generated from workflow-pack go-rules v1.3.0 -->
+<!-- adapted from affaan-m/ECC (MIT) — https://github.com/affaan-m/ECC -->
+
+## Go conventions (beyond what the linter enforces)
+
+`gofmt`, `goimports`, and `go vet` already catch formatting and the obvious mistakes — this pack is the judgment they can't encode. Keep the mechanical checks in CI (`gofmt -l .`, `go vet ./...`, `go test -race ./...`, `gosec ./...`); the reviewer covers the rest.
+
+### API shape
+
+- Accept interfaces, return structs. Define an interface where it is consumed (1-3 methods), never next to the implementation.
+- Use functional options (`type Option func(*Server)`) for constructors with many optional parameters, not a giant config struct or a long positional list.
+- Inject dependencies through constructors (`NewUserService(repo, logger)`), never package-level globals.
+
+### Errors
+
+- Wrap every propagated error with context and `%w` (`fmt.Errorf("create user: %w", err)`). A bare returned `err` with no origin is a defect, not a shortcut.
+
+### Concurrency
+
+- Thread `context.Context` through call chains for cancellation and timeout (`ctx, cancel := context.WithTimeout(ctx, 5*time.Second)`; `defer cancel()`).
+- Every piece of shared state has an explicit owner — a mutex or a channel — or a comment proving why it is safe. "Probably fine" is a race.
+
+### Boundaries
+
+- Validate external input at the boundary before it reaches business logic; fail fast with a clear message.
+- Read required secrets from the environment and `log.Fatal` on an empty value at startup — never a silent zero value.
+
+### Flag in review (a linter won't)
+
+- A propagated error with no `%w` and no context string.
+- An interface defined beside its implementation instead of its consumer.
+- Shared state touched by multiple goroutines with no mutex/channel and no safety comment.
+- A required env var read without an empty-check before use.
+
+## Workflow pack: Go rules
+
+Go conventions a linter can't check — interfaces accepted not returned, errors wrapped with context, functional options, owned shared state — with a reviewer and a gofmt guard; formatting, vet, and races belong in CI.
+
+### Roles
+
+- **go-reviewer** — Reviews changed Go against the Go standards: interfaces, wrapped errors, context threading, race safety, and env-var secrets. Reports file:line + severity. Use after any Go change.
+
+### Commands
+
+- **/go-review** `[base ref]` — Run the Go reviewer over the current change against this pack's Go standards.
+  - How it runs: Invoke the go-reviewer subagent on the changed Go files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — consumer-defined interfaces, errors wrapped with %w and context, functional options, context threading, explicitly owned shared state, boundary validation, and fail-fast env-var secrets — and reports file:line + severity. Formatting, go vet, and races are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging.
+
+### Guardrails
+
+- After an edit, check Go formatting with gofmt when it is installed.
+
+Tool-specific implementations live alongside this file (see `CLAUDE.md` for the Claude Code implementation). Tools without a native subagent/command surface should treat the sections above as operating instructions.

package/packs/go-rules/rendered/CLAUDE.md

@@ -0,0 +1,8 @@
+# CLAUDE.md
+
+@AGENTS.md
+
+This project defines a native Claude Code implementation of this workflow pack:
+- Subagent: `.claude/agents/go-reviewer.md`
+- Command: `.claude/commands/go-review.md`
+- Hooks: see `.claude/settings.json`

package/packs/go-rules/rendered/GEMINI.md

@@ -0,0 +1,3 @@
+# GEMINI.md
+
+@AGENTS.md

package/packs/python-rules/pack.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://baselane.dev/schema/workflow-pack-v1.json",
+  "id": "python-rules",
+  "version": "1.3.0",
+  "title": "Python rules",
+  "summary": "Python conventions a linter can't check — frozen dataclasses for value objects, Protocols for structural typing, raise ... from, os.environ[] over silent .get() fallbacks — with a reviewer and a ruff guard; style and coverage belong in CI.",
+  "scope": "repo",
+  "attribution": { "source": "affaan-m/ECC", "url": "https://github.com/affaan-m/ECC", "license": "MIT" },
+  "context": {
+    "markdown": "## Python conventions (beyond what the linter enforces)\n\n`ruff` and `black` already enforce PEP 8, import order, bare `except`, and mutable default arguments — this pack is the judgment they can't encode. Keep the mechanical checks in CI (`ruff check .`, `bandit -r src/`, `pytest --cov`); the reviewer covers the rest.\n\n### Data shapes\n\n- Model value objects as `@dataclass(frozen=True)` or `NamedTuple`, not a mutable class with public attributes.\n- Use a `Protocol` when a caller needs only an interface, not a concrete base class; use plain `@dataclass` for request/DTO shapes at API and service boundaries.\n- Acquire every resource (files, locks, connections) through a context manager (`with`); use generators for lazy, memory-efficient iteration.\n\n### Types\n\n- Annotate every function signature, including internal helpers — not just the public API a type checker would force.\n\n### Errors\n\n- Catch specific exception types and preserve the chain when wrapping (`raise NewError(...) from err`); never swallow into a bare `except` or drop the cause.\n\n### Boundaries\n\n- Validate external input at the boundary before it reaches business logic; fail fast with a clear message (Pydantic or an explicit check).\n- Read required secrets with `os.environ[\"KEY\"]` so a missing value raises at startup — never `os.environ.get(...)` with a fallback that lets a misconfigured app boot.\n\n### Flag in review (a linter won't)\n\n- A mutable class used where a frozen value object belongs.\n- A concrete base class used where a `Protocol` would decouple the caller.\n- A wrapped exception that drops `from err` and loses the cause.\n- A required secret read via `.get()` with a silent fallback default.\n"
+  },
+  "agents": [
+    {
+      "name": "python-reviewer",
+      "description": "Reviews changed Python against the Python standards: type hints, immutability, specific exceptions, boundary validation, and env-var secrets. Reports file:line + severity. Use after any Python change.",
+      "tools": ["Read", "Grep", "Glob", "Bash"],
+      "model": "sonnet",
+      "prompt": "You are a Python reviewer. Read the changed Python files and check them against the conventions in context: frozen dataclasses/NamedTuples for value objects, Protocols for structural typing, context managers for resources, full signature annotations, specific-exception handling with `raise ... from`, boundary input validation, and `os.environ[...]` secrets that fail fast. PEP 8, import order, and coverage are the linter/CI's job — don't re-litigate them. Cite the exact file:line for each finding, name the concrete failure mode, and give severity. If the change is sound, say so plainly rather than inventing findings."
+    }
+  ],
+  "commands": [
+    {
+      "name": "python-review",
+      "description": "Run the Python reviewer over the current change against this pack's Python standards.",
+      "argument_hint": "[base ref]",
+      "prompt": "Invoke the python-reviewer subagent on the changed Python files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — frozen dataclasses for value objects, Protocols for structural typing, `raise ... from`, and os.environ[] over silent .get() fallbacks — and reports file:line + severity. Style and coverage are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging."
+    }
+  ],
+  "hooks": [
+    {
+      "event": "PostToolUse",
+      "matcher": "Edit|Write",
+      "description": "After an edit, lint with ruff when it is installed.",
+      "action": "run-command",
+      "command": "if command -v ruff >/dev/null 2>&1; then ruff check .; else echo \"ruff not found — pip install ruff to lint (python-rules)\"; fi"
+    }
+  ]
+}

package/packs/python-rules/rendered/.claude/agents/python-reviewer.md

@@ -0,0 +1,8 @@
+---
+name: python-reviewer
+description: Reviews changed Python against the Python standards: type hints, immutability, specific exceptions, boundary validation, and env-var secrets. Reports file:line + severity. Use after any Python change.
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+You are a Python reviewer. Read the changed Python files and check them against the conventions in context: frozen dataclasses/NamedTuples for value objects, Protocols for structural typing, context managers for resources, full signature annotations, specific-exception handling with `raise ... from`, boundary input validation, and `os.environ[...]` secrets that fail fast. PEP 8, import order, and coverage are the linter/CI's job — don't re-litigate them. Cite the exact file:line for each finding, name the concrete failure mode, and give severity. If the change is sound, say so plainly rather than inventing findings.

package/packs/python-rules/rendered/.claude/commands/python-review.md

@@ -0,0 +1,6 @@
+---
+description: Run the Python reviewer over the current change against this pack's Python standards.
+argument-hint: [base ref]
+---
+
+Invoke the python-reviewer subagent on the changed Python files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — frozen dataclasses for value objects, Protocols for structural typing, `raise ... from`, and os.environ[] over silent .get() fallbacks — and reports file:line + severity. Style and coverage are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging.

package/packs/python-rules/rendered/.claude/settings.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if command -v ruff >/dev/null 2>&1; then ruff check .; else echo \"ruff not found — pip install ruff to lint (python-rules)\"; fi"
+          }
+        ]
+      }
+    ]
+  }
+}

package/packs/python-rules/rendered/.github/copilot-instructions.md

@@ -0,0 +1,43 @@
+# Copilot instructions
+
+## Python conventions (beyond what the linter enforces)
+
+`ruff` and `black` already enforce PEP 8, import order, bare `except`, and mutable default arguments — this pack is the judgment they can't encode. Keep the mechanical checks in CI (`ruff check .`, `bandit -r src/`, `pytest --cov`); the reviewer covers the rest.
+
+### Data shapes
+
+- Model value objects as `@dataclass(frozen=True)` or `NamedTuple`, not a mutable class with public attributes.
+- Use a `Protocol` when a caller needs only an interface, not a concrete base class; use plain `@dataclass` for request/DTO shapes at API and service boundaries.
+- Acquire every resource (files, locks, connections) through a context manager (`with`); use generators for lazy, memory-efficient iteration.
+
+### Types
+
+- Annotate every function signature, including internal helpers — not just the public API a type checker would force.
+
+### Errors
+
+- Catch specific exception types and preserve the chain when wrapping (`raise NewError(...) from err`); never swallow into a bare `except` or drop the cause.
+
+### Boundaries
+
+- Validate external input at the boundary before it reaches business logic; fail fast with a clear message (Pydantic or an explicit check).
+- Read required secrets with `os.environ["KEY"]` so a missing value raises at startup — never `os.environ.get(...)` with a fallback that lets a misconfigured app boot.
+
+### Flag in review (a linter won't)
+
+- A mutable class used where a frozen value object belongs.
+- A concrete base class used where a `Protocol` would decouple the caller.
+- A wrapped exception that drops `from err` and loses the cause.
+- A required secret read via `.get()` with a silent fallback default.
+
+## Workflow pack: Python rules
+
+Python conventions a linter can't check — frozen dataclasses for value objects, Protocols for structural typing, raise ... from, os.environ[] over silent .get() fallbacks — with a reviewer and a ruff guard; style and coverage belong in CI.
+
+When acting as the python-reviewer role: You are a Python reviewer. Read the changed Python files and check them against the conventions in context: frozen dataclasses/NamedTuples for value objects, Protocols for structural typing, context managers for resources, full signature annotations, specific-exception handling with `raise ... from`, boundary input validation, and `os.environ[...]` secrets that fail fast. PEP 8, import order, and coverage are the linter/CI's job — don't re-litigate them. Cite the exact file:line for each finding, name the concrete failure mode, and give severity. If the change is sound, say so plainly rather than inventing findings.
+
+Workflow steps:
+
+- python-review: Invoke the python-reviewer subagent on the changed Python files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — frozen dataclasses for value objects, Protocols for structural typing, `raise ... from`, and os.environ[] over silent .get() fallbacks — and reports file:line + severity. Style and coverage are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging.
+
+- After an edit, lint with ruff when it is installed.

package/packs/python-rules/rendered/AGENTS.md

@@ -0,0 +1,53 @@
+# AGENTS.md
+
+<!-- generated from workflow-pack python-rules v1.3.0 -->
+<!-- adapted from affaan-m/ECC (MIT) — https://github.com/affaan-m/ECC -->
+
+## Python conventions (beyond what the linter enforces)
+
+`ruff` and `black` already enforce PEP 8, import order, bare `except`, and mutable default arguments — this pack is the judgment they can't encode. Keep the mechanical checks in CI (`ruff check .`, `bandit -r src/`, `pytest --cov`); the reviewer covers the rest.
+
+### Data shapes
+
+- Model value objects as `@dataclass(frozen=True)` or `NamedTuple`, not a mutable class with public attributes.
+- Use a `Protocol` when a caller needs only an interface, not a concrete base class; use plain `@dataclass` for request/DTO shapes at API and service boundaries.
+- Acquire every resource (files, locks, connections) through a context manager (`with`); use generators for lazy, memory-efficient iteration.
+
+### Types
+
+- Annotate every function signature, including internal helpers — not just the public API a type checker would force.
+
+### Errors
+
+- Catch specific exception types and preserve the chain when wrapping (`raise NewError(...) from err`); never swallow into a bare `except` or drop the cause.
+
+### Boundaries
+
+- Validate external input at the boundary before it reaches business logic; fail fast with a clear message (Pydantic or an explicit check).
+- Read required secrets with `os.environ["KEY"]` so a missing value raises at startup — never `os.environ.get(...)` with a fallback that lets a misconfigured app boot.
+
+### Flag in review (a linter won't)
+
+- A mutable class used where a frozen value object belongs.
+- A concrete base class used where a `Protocol` would decouple the caller.
+- A wrapped exception that drops `from err` and loses the cause.
+- A required secret read via `.get()` with a silent fallback default.
+
+## Workflow pack: Python rules
+
+Python conventions a linter can't check — frozen dataclasses for value objects, Protocols for structural typing, raise ... from, os.environ[] over silent .get() fallbacks — with a reviewer and a ruff guard; style and coverage belong in CI.
+
+### Roles
+
+- **python-reviewer** — Reviews changed Python against the Python standards: type hints, immutability, specific exceptions, boundary validation, and env-var secrets. Reports file:line + severity. Use after any Python change.
+
+### Commands
+
+- **/python-review** `[base ref]` — Run the Python reviewer over the current change against this pack's Python standards.
+  - How it runs: Invoke the python-reviewer subagent on the changed Python files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — frozen dataclasses for value objects, Protocols for structural typing, `raise ... from`, and os.environ[] over silent .get() fallbacks — and reports file:line + severity. Style and coverage are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging.
+
+### Guardrails
+
+- After an edit, lint with ruff when it is installed.
+
+Tool-specific implementations live alongside this file (see `CLAUDE.md` for the Claude Code implementation). Tools without a native subagent/command surface should treat the sections above as operating instructions.

package/packs/python-rules/rendered/CLAUDE.md

@@ -0,0 +1,8 @@
+# CLAUDE.md
+
+@AGENTS.md
+
+This project defines a native Claude Code implementation of this workflow pack:
+- Subagent: `.claude/agents/python-reviewer.md`
+- Command: `.claude/commands/python-review.md`
+- Hooks: see `.claude/settings.json`

package/packs/python-rules/rendered/GEMINI.md

@@ -0,0 +1,3 @@
+# GEMINI.md
+
+@AGENTS.md

package/packs/second-brain/pack.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://baselane.dev/schema/workflow-pack-v1.json",
+  "id": "second-brain",
+  "version": "1.0.0",
+  "title": "Second Brain (OKF)",
+  "summary": "A durable second brain for every repo and laptop: an Open Knowledge Format (OKF) wiki for project knowledge — architecture, decisions, gotchas, runbooks — plus a memory store of durable one-line facts, maintained by a librarian subagent that ingests what the team learns and lints for contradictions. The discipline is read-before-acting and write-after-learning, and the AI keeps the bookkeeping, not you. Built on the Karpathy \"LLM Wiki\" ingest/query/lint loop and Google's Open Knowledge Format. It ships the format and the habit, not pre-filled content — the brain accumulates as the team works.",
+  "scope": "both",
+  "context": {
+    "markdown": "## Second brain (OKF wiki + memory)\n\nThis project keeps a durable second brain the AI reads before acting and writes after learning:\n\n- `.baselane/wiki/` — an Open Knowledge Format (OKF) knowledge base for project knowledge: architecture, decisions, gotchas, runbooks. One concept per file (with a `type` frontmatter field), plus an `index.md` and an append-only `log.md`.\n- `.baselane/memory/` — durable one-line facts (decisions, corrections, non-obvious constraints), indexed by `MEMORY.md`.\n\nRead `index.md` and `MEMORY.md` before acting — recall what's already known rather than re-deriving it. After learning something durable, ingest it (a wiki page or a memory fact) together with its index and log lines. Corrections beat additions: reconcile contradictions rather than letting them pile up. Use `/wiki` and `/remember` for one-step capture; the `librarian` subagent handles the bookkeeping and periodic lint.\n"
+  },
+  "capabilities": [
+    { "type": "wiki", "store": "repo", "method": "baselane" },
+    { "type": "wiki", "store": "org", "method": "baselane" },
+    { "type": "memory", "store": "repo", "method": "files" },
+    { "type": "memory", "store": "org", "method": "files" }
+  ],
+  "agents": [
+    {
+      "name": "librarian",
+      "description": "Knowledge-base keeper: ingests durable knowledge into the OKF wiki and memory, and lints them for contradictions, stale claims, orphan pages, and broken cross-links.",
+      "tools": ["Read", "Grep", "Glob", "Edit", "Write"],
+      "model": "sonnet",
+      "prompt": "You are the librarian for this project's second brain (`.baselane/wiki/` and `.baselane/memory/`). You have two jobs.\n\n(1) Ingest. When the session learned something durable — an architectural fact, a decision, a gotcha, a correction — record it. Project knowledge goes in the OKF wiki (`.baselane/wiki/`: one concept per file with a `type` frontmatter field, plus its `index.md` line and a `log.md` entry). A durable one-line fact goes in memory (`.baselane/memory/`, with its `MEMORY.md` line). Follow the protocol in each directory's README.\n\n(2) Lint. On request (or via `/wiki lint`), scan every wiki page and memory fact for contradictions between pages, stale claims, pages missing from the index, and broken cross-links. Reconcile contradictions rather than letting them coexist — corrections beat additions.\n\nAlways read `index.md` and `MEMORY.md` before acting. Never fabricate a page or a fact; only record what the work actually established. Keep the bookkeeping — the index and log lines — current; that is your job, not the human's."
+    }
+  ],
+  "commands": [],
+  "hooks": [
+    {
+      "event": "SessionStart",
+      "matcher": "",
+      "description": "At session start, recall the second brain before acting.",
+      "action": "print-reminder",
+      "message": "Recall the second brain before acting: read .baselane/wiki/index.md and .baselane/memory/MEMORY.md first — the answer may already be written down."
+    }
+  ]
+}

package/packs/second-brain/rendered/.baselane/capabilities.json

@@ -0,0 +1,25 @@
+{
+  "version": 1,
+  "capabilities": [
+    {
+      "type": "wiki",
+      "store": "repo",
+      "method": "baselane"
+    },
+    {
+      "type": "wiki",
+      "store": "org",
+      "method": "baselane"
+    },
+    {
+      "type": "memory",
+      "store": "repo",
+      "method": "files"
+    },
+    {
+      "type": "memory",
+      "store": "org",
+      "method": "files"
+    }
+  ]
+}