@se-studio/skills 1.9.8 → 1.9.10

package/skills/principle-boundary-discipline/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: principle-boundary-discipline
+description: "Apply when wiring validation, error handling, or framework adapters. Concentrate guards at system boundaries (CLI, config, network, external APIs); trust internal types and keep business logic in pure functions."
+---
+
+# Boundary Discipline
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+Place validation, type narrowing, and error handling at system boundaries. Trust internal code unconditionally. Business logic lives in pure functions. The shell is thin and mechanical.
+
+**Why:** Scattered validation is noisy, redundant, and gives a false sense of safety. Keep logic out of framework wiring so it can be tested without the framework.
+
+**The pattern:**
+- **At boundaries** (CLI args, config files, external APIs, network protocols): validate, return errors, handle defensively.
+- **Inside the system:** typed data, error propagation, no re-validation. Trust the types.
+- **Across the boundary.** Expose domain concepts, not the boundary's private representation. Keep general-purpose mechanism inside and special-purpose policy at the edge.
+
+**Applications:**
+
+Validation and error handling:
+- Validate config at parse time (the boundary), not inside business logic
+- Parse raw data into domain types at the boundary
+- Do not re-export transport, storage, framework, or wire types through the public surface
+- No redundant nil checks deep in call chains if the boundary already validated
+
+Code organization:
+- Business logic in pure functions with no framework dependencies
+- Parse functions: pure transforms from raw bytes to typed state
+- Prompt construction: structured state in, string out
+- Scoring and assessment: pure transforms from state to results
+
+**The tests:**
+- "Is this data crossing a system boundary right now?" If not, validation is redundant.
+- "Can this be a pure function that the shell just calls?" If yes, extract it.

package/skills/principle-encode-lessons-in-structure/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: principle-encode-lessons-in-structure
+description: "Apply when you catch yourself writing the same instruction a second time, or notice a recurring correction. Encode the rule as a lint, metadata flag, runtime check, or script instead of more text."
+---
+
+# Encode Lessons in Structure
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+If the lesson needs judgment and cannot be encoded, make the instruction more prominent and add an example of the failure mode.
+
+**Corollary:** If the fix is structural, only use the structural fix. The instruction is the symptom.

package/skills/principle-fix-root-causes/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: principle-fix-root-causes
+description: "Apply when debugging. Trace each symptom to its root cause and fix it there; reproduce first, ask why until you reach it, resist nil-check guards that silence crashes."
+---
+
+# Fix Root Causes
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+When debugging, do not fix symptoms. Trace every problem to its root cause and fix it there.
+
+**Why:** Symptom fixes accumulate. Each workaround makes the system harder to reason about, and the real bug remains. Root-cause fixes are slower upfront but reduce total debugging time.
+
+**Pattern:**
+- Reproduce first
+- Ask "why" until you hit the root cause
+- Do not add guards (adding a nil check to silence a crash is a symptom fix)
+- If a workaround needs a paragraph-long comment to justify it, the code is wrong (fix the code, not the comment)
+- Check for the pattern, not just the instance (grep for the same pattern, fix all instances)
+- When stuck, instrument. Don't guess (add logging, read the actual error)
+
+**Restart bugs: suspect state before code**
+
+When something "fails after restart," suspect stale persistent state first: config files, caches, lock files, serialized state. If clearing a state file restores behavior, prioritize state validation as the fix.

package/skills/principle-guard-the-context-window/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: principle-guard-the-context-window
+description: "Apply when context is filling up: large outputs, long files, repeated reads, fan-out planning. Route bulk to subagents; keep summaries in the main thread, not raw payloads."
+---
+
+# Guard the Context Window
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+**Why:** Context overflow degrades reasoning quality, creates compression artifacts, and halts progress.
+
+**Pattern:**
+- **Size phases and cap scope.** Limit files per phase, set turn budgets, account for mechanism costs.

package/skills/principle-make-operations-idempotent/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: principle-make-operations-idempotent
+description: "Apply when designing commands, lifecycle steps, or processing loops that run amid crashes, restarts, and retries. Converge to the same end state regardless of partial prior runs."
+---
+
+# Make Operations Idempotent
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+Design operations so they converge to the correct state regardless of how many times they run or where they start from. Every state-mutating operation should answer: "What happens if this runs twice? What happens if the previous run crashed halfway?"
+
+**Why:** Commands, lifecycle operations, and processing loops run where crashes, restarts, and retries are normal. If partial state changes the next run's outcome, every restart becomes a debugging session.
+
+**The pattern:**
+- Convergent startup: scan for existing state, clean stale artifacts, adopt live sessions
+- Content-based cleanup: compare by content equivalence, not creation order
+- Self-healing locks: use PID-based stale lock detection
+- Idempotent scheduling: failed work respawns cleanly, fresh input regenerated after each cycle
+
+**The test:**
+1. What happens if this runs twice in a row?
+2. What happens if the previous run crashed at every possible point?
+3. Does re-execution converge to the same end state?
+
+If any answer is "it depends on what state was left behind," the operation needs a reconciliation step.

package/skills/principle-minimize-reader-load/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: principle-minimize-reader-load
+description: "Apply when reviewing or shaping code that's hard to trace. Count layers between question and answer, and hidden state in the reader's head; collapse one-caller wrappers and shrink mutable scope."
+---
+
+# Minimize Reader Load
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+Maintainability is the work a reader must do to understand code. Track two axes: **layers to trace** (indirections between the question and the answer) and **state to hold** (hidden or mutable context the reader must keep in their head). LOC, cyclomatic complexity, and "clean architecture" are proxies. Reader load is the thing that matters. The two axes are independent. A flat file with 50 globals can be as hard to reason about as a 6-layer adapter stack. Guard both. This is the human analog of [Guard the Context Window](../principle-guard-the-context-window/SKILL.md). Working memory is finite for readers too.
+
+- **Collapse layers** that cost more than they save: wrappers with one caller, adapters with no second implementation, speculative indirection that was never needed. Inline them.
+- **Make adjacent layers change the abstraction.** A layer that repeats the same methods and arguments adds reader load without compression. Collapse pass-through layers.
+- **Demand interface compression.** A broad interface that hides little complexity makes readers learn both the surface and the implementation. Prefer boundaries that hide meaningful decisions.
+- **Shrink state scope:** prefer pure functions (returns over mutations), locals over fields, fields over module state, and module state over globals. Derive instead of sync.
+- **Name the invariant at the boundary,** not in every consumer, so the reader learns it once.
+- Before adding a layer or a piece of state, ask: does it reduce reader load elsewhere by at least as much?
+
+**The test:** can a new reader answer "where does X come from?" and "what can change X?" in under 30 seconds? If not, cut layers or cut state.

package/skills/principle-model-the-domain/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: principle-model-the-domain
+description: "Apply when writing stateful logic, or when code branches a lot or repeats a shape assumption across files."
+---
+
+# Model the Domain
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+Encode the real domain in a data structure instead of scattering it across conditionals. A structure that matches the domain makes invalid states unrepresentable and deletes branches. Choosing it at write time is cheap. Recovering it later reads as a refactor and gets deferred.
+
+Reach for:
+
+- A state machine instead of scattered booleans, phases, or lifecycle checks.
+- A typed model instead of loose parameters or repeated shape assumptions.
+- A map, registry, lookup table, or discriminated union instead of branching spread across files.
+- A reducer or command/event model instead of ad hoc state mutations.
+- A module organized around one body of domain knowledge instead of a sequence such as load, validate, transform, and save. Execution order is not ownership.
+- A small module boundary that gathers repeated behavior, ownership, or invariants.
+- A queue, cache, index, graph, tree, or normalized collection where the access pattern calls for it.
+- Any other structure that fits. When none fits, work out what the code must never allow and how the data gets read, then find the structure that encodes exactly that.
+
+Do not force an abstraction. Prefer boring code if the current shape is already clear, local, and unlikely to grow. Be skeptical of an abstraction that adds indirection without removing branches, duplicated rules, invalid states, or lifecycle risk.
+
+The sign that you skipped this is a new feature that grows an existing if/else chain by one more branch, or a second boolean that must stay in sync with the first. Temporal decomposition is another sign. Phase-named modules repeat the same domain rules across steps.

package/skills/principle-prove-it-works/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: principle-prove-it-works
+description: "Apply after completing a task, before declaring done. Verify against the real artifact (run the feature, read the actual value, inspect the diff), not a proxy, self-report, or 'it compiles.'"
+---
+
+# Prove It Works
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+Verify every task output by checking the real thing directly. Do not infer from proxies, self-reports, or "it compiles."
+
+**Why:** Unverified work has unknown correctness. Indirect verification (file mtimes, output freshness, agent self-reports, cached screenshots) feels cheaper than direct observation. Acting on a wrong inference costs far more than checking the source.
+
+Check the real thing, not a proxy:
+- Check process liveness directly, not indirectly through derived state
+- Read the actual value, not a cached or derived representation
+- When verification fails, suspect the observation method before suspecting the system
+
+## Script the check when you can
+
+The strongest proof is a deterministic script that re-runs the same comparison, not a one-time eyeball. Write the script, run it, and keep its output as an artifact a reviewer can re-run instead of trusting your word.
+
+Keep the artifact visible for the human. Commit it only for large or complex work where the trail has to be auditable later, like a big port or migration. If a **show-me-your-work** skill is installed, follow it; otherwise (**skip if missing**) keep artifacts under the usual Project / walkthrough paths without installing that skill.

package/skills/principle-sequence-verifiable-units/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: principle-sequence-verifiable-units
+description: "Apply to multi-step work (sweeps, migrations, runs of similar edits) and to how you stack commits and PRs. Break work into small units that each end in a verifiable state, check each before the next, and order delivery so the sequence proves itself to a reviewer."
+---
+
+# Sequence work into verifiable units
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+Order work as a sequence of small units, each ending in a state you can check, and don't advance until the current one is green.
+
+**Why:** A break caught at the unit that caused it is cheap to localize. A break caught after a batch is buried, and you have already built further on a broken base. Sequencing those same units into a delivery a reviewer can replay turns "trust me" into "watch it go red, then green."
+
+**Execution.** In a sweep, migration, or any run of similar edits, verify each change before starting the next. Each unit is a before/after bracket: known-good state, one change, run the check, then proceed. Rebase onto clean trunk first so every check measures against the real baseline. When a lever does the edits, the per-unit check is nearly free. Run it anyway.
+
+**Delivery.** Stack commits and PRs in the order that proves the work. The canonical shape is the failing test first, then the fix on top. Other story orders are a subtraction before the reshape, a baseline capture before the treatment, the scaffold before the feature. Each commit lands on its own and the sequence reads as an argument.
+
+The sequencing complement to the **prove-it-works** principle skill, which keeps each check real. If a **build-the-lever** principle skill is installed, also use it to make per-unit checks cheap; otherwise (**skip if missing**) keep checks cheap with existing scripts/tests and do not install that skill.

package/skills/principle-subtract-before-you-add/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: principle-subtract-before-you-add
+description: "Apply when sequencing an addition, refactor, or rewrite. Remove dead code, redundant validators, and stub references first, then build on the simpler base."
+---
+
+# Subtract Before You Add
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+When evolving a system, remove complexity first, then build. Default to subtraction.
+
+Make simplification a continual investment. Leave the design slightly simpler and more capable behind the same or smaller surface than you found it.
+
+- Sequence removal before construction
+- Cut before you polish (get to the minimum before investing in quality)
+- Design for observed usage, not speculative edge cases
+- No speculative validators, parsers, or guards beyond what the spec demands
+- Simplify prompts (remove redundant instructions, excessive templates)
+- When a reference has no novel content, delete it rather than leaving a stub

package/skills/principle-test-behavior-not-implementation/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: principle-test-behavior-not-implementation
+description: "Apply when you write, change, or keep a test. Call the code as its users do and assert the exact result they see. Rewrite or delete a test that would pass if every imported function returned undefined."
+---
+
+# Test Behavior, Not Implementation
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+A test calls the code as its users do and asserts the exact result they see. Rewrite or delete any test that would still pass if every imported function returned `undefined` or a wrong value.
+
+These shapes fail that check:
+
+- Loose or no assertion: `toBeDefined`, `toBeTruthy`, `not.toThrow`, `toBeGreaterThan(0)`.
+- Call or absence only: `toHaveBeenCalled`, `not.toHaveBeenCalled`, `toBeUndefined`, `toEqual([])`.
+- Expected value computed by the code under test: `expect(f(a)).toBe(f(a))`.
+- Restated constant, config default, table row, or prompt string.
+- Assertions on data the test built, with no call to the subject.
+
+Fix: call the subject in the test body with one concrete input and assert the literal output or effect. For a mock, assert the payload it received. For an absence, also assert the presence on another input. For a constant, test the mechanism that reads it with one input instead of restating the value.
+
+Keep relation checks across table rows (a key in two tables, a parent that exists) and `*.test-d.ts` type checks.

package/skills/principle-type-system-discipline/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: principle-type-system-discipline
+description: "Apply when designing types, reviewing a function signature, or writing code in any statically-typed language. Make illegal states unrepresentable, brand semantic primitives, parse external data at boundaries, refuse to lie to the compiler, exhaust variants, derive from authoritative schemas."
+---
+
+# Type System Discipline
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+Make the compiler reject impossible states, mismatched primitives, and unhandled variants. Prefer defining errors and special cases out of existence over proliferating handlers. For TypeScript syntax, see the `typescript-best-practices` skill.
+
+- **Make illegal states unrepresentable.** Model variants as sum types (discriminated unions, enums with payloads, sealed classes), not as a bag of optional fields where contradictory combinations compile. `{ completed: boolean; completedAt?: Date }` admits `completed: true` with no date. Derive the boolean from `completedAt`, or model `{ kind: 'open' } | { kind: 'done'; at: Date }`. If you can write a comment explaining when a combination of fields is valid, split it into a sum type.
+- **Types are constructions, not restrictions.** Build the type up from the values you want instead of carving them out of a looser type with checks. A non-empty list is a head plus a rest. A valid time range is a start plus a duration. Choose the shape that cannot build the illegal value and expose the interface callers need on top.
+- **Brand semantic primitives.** `UserId` and `OrderId` are strings underneath but should not be interchangeable. Give each its own type, such as a branded intersection in TypeScript or a newtype elsewhere. Validate once at creation, trust the type downstream. If two arguments share a primitive type but mean different things, brand them.
+- **External data is untyped until parsed.** RPC payloads, JSON, IPC messages, CLI args, config files, environment variables, database rows. Have a parse function at every boundary that turns unstructured input into the typed model. The **boundary-discipline** principle skill says where to put validation.
+- **Don't lie to the type system.** Casts, unsafe coercions, and assertion functions that bypass the compiler are latent runtime crashes. If the compiler can't prove a fact, prove it (validate, narrow, refine the model) or accept that the cast is a hazard. Trace each `any`, `as`, or `assertNotNull` to the boundary and validate there.
+- **Exhaustive matching is the compiler's job.** A match on a sum type must fail compilation when a new variant is added without handling, so the compiler tells the next agent where to add a case. Use your language's idiom: a `never`-typed binding in TypeScript, an unannotated `match` in Rust, `-Wincomplete-patterns` in Haskell, sealed-class match exhaustiveness in Kotlin.
+- **Derive types from authoritative schemas.** When a protocol buffer, OpenAPI spec, GraphQL schema, database migration, design-token file, or another file owns a shape, derive from it instead of hand-rolling a parallel type. See the **encode-lessons-in-structure** principle skill.
+- **Strengthen a type only where partiality appears.** A runtime assertion, null check, or "this should never happen" throw marks the place a type is too weak. Push that check up into the type. Then stop. The type system's job is to track the cases each use site must handle, not to describe the data as precisely as possible. Prefer total functions. `sum` of an empty list is 0, so it takes the plain list. `head` of an empty list has no answer, so it demands the non-empty one. If nothing would otherwise panic, keep the plain type.

package/skills/se-marketing-sites-smoke-test-setup/SKILL.md

@@ -276,6 +276,32 @@ Add `/llms.txt`, `/markdown-index.txt`, and `/site-info.md` to `route-build-poli
 
 `expectHtmlStatus` requires `@se-studio/site-check@^2.7.2`. Omit for normal 2xx HTML checks.
 
+### Content assertions (release verification)
+
+Live / production smoke must assert **key blocks render**, not only HTTP 200 (release verification rule 2). Add optional `contentAssert` on representative cases:
+
+```json
+{
+  "category": "person",
+  "label": "Provider — hero",
+  "path": "/providers/jane-doe/",
+  "expectMarkdown": true,
+  "contentAssert": {
+    "mustInclude": ["Jane Doe"],
+    "mustHaveSelector": ["img"],
+    "imagesMustLoad": true
+  }
+}
+```
+
+| Field | Meaning |
+|-------|---------|
+| `mustInclude` | Substrings that must appear in the HTML body |
+| `mustHaveSelector` | Cheap checks: tag (`img`, `h1`), `.class`, `#id`, or `img[src]` |
+| `imagesMustLoad` | Every `<img src>` must return HTTP 2xx |
+
+Use on person heroes (name + headshot) and listing cards (images). Requires a site-check version that exports content-assert support. See `docs/RELEASE_VERIFICATION.md`.
+
 Optional `cmsIntegrity` (local only — see section below):
 
 ```json
@@ -410,7 +436,7 @@ Commit `route-build-policy.json` beside `smoke.cases.json`. Start from `@se-stud
 
 `pnpm smoke-test:cache` / `smoke-test:deploy-check` catches breakage lint/policy miss. Keep mandatory in CI / Vercel build gates.
 
-**HubSpot bootstrap:** use `createHubSpotBootstrapScript()` with no args in root layout — not `headers()` + middleware pathname.
+**HubSpot bootstrap (only if the site uses HubSpot tracking):** use `createHubSpotBootstrapScript()` with no args in root layout — not `headers()` + middleware pathname.
 
 ## Deploy / live smoke failure playbook
 

package/skills/site-workflows-agent-session/SKILL.md

@@ -5,7 +5,7 @@ description: "Start and manage agent work sessions across se-core-product and cu
 
 # Agent session workflow
 
-Orchestrates **where** to work, **where code belongs**, and **how to isolate parallel features**. Customer production merges need a **human ask plus a second confirmation** ([`production-merge.md`](../../references/agent-session/production-merge.md)). **se-core-product `main` is never agent.**
+Orchestrates **where** to work, **where code belongs**, and **how to isolate parallel features**. Customer production merges **and** se-core-product `dev` → `main` (npm promote) need a **human ask plus a second confirmation** ([`production-merge.md`](../../references/agent-session/production-merge.md)).
 
 **Registry:** [`packages/skills/references/agent-session/projects.registry.json`](../../references/agent-session/projects.registry.json) — repo paths, `worktreesRoot`, `productionPath` / `productionBranch`, integration branches, hosted MCP keys, `localEnvRoot`.
 
@@ -61,11 +61,21 @@ Integration branches (agents push feature branches here via PR or merge — **ne
 
 | Repo type | Integration branch | Production |
 |-----------|-------------------|------------|
-| `se-core-product` | `dev` | `main` — **never** agent |
+| `se-core-product` | `dev` | `main` — ask + confirm ([`production-merge.md`](../../references/agent-session/production-merge.md); publishes npm) |
 | Customer sites | `develop` (or registry override) | Usually `main`; HSD **`production`**. Merge only after [`production-merge.md`](../../references/agent-session/production-merge.md) (ask + confirm) |
 
 **Never** work in `productionPath`. Agent work uses `path` (develop checkout) only.
 
+### Fleet status
+
+Run this at the **start** of every coding session, and **again before you say the session is done**:
+
+```bash
+pnpm --dir ~/source/se/se-core-product fleet-status
+```
+
+Read the whole report before editing. A tracked dirty file or a worktree is unfinished work: commit it, push it, drop it, or name it in the handoff. Do not start another feature on a dirty primary checkout. The script lists every registry checkout, hides generated paths, and is the only list of those paths.
+
 ---
 
 ## Step 2 — Ledger: PRs and worktrees (not yaml)
@@ -74,8 +84,8 @@ Customer-only work **must not** create or update files in `se-core-product`. Cro
 
 **What's in flight** (when the user asks, or before a tidy-up):
 
-1. **Open PRs** targeting `dev` (core) or `develop` (customer) — `gh pr list --base <integration> --state open`. This includes Cursor cloud / other machines.
-2. **This machine:** `git fetch --prune` then `git worktree list` on the registry primary checkout.
+1. **This machine:** `pnpm --dir ~/source/se/se-core-product fleet-status`.
+2. **Open PRs** targeting `dev` (core) or `develop` (customer) — `gh pr list --base <integration> --state open`. This includes Cursor cloud / other machines. Fleet-status does not see those.
 
 Do not invent a second ledger in git. Stale local trees vs merged PRs are a prune problem, not a yaml problem.
 
@@ -292,10 +302,11 @@ Agents may push to:
 - `dev` / `develop` (via feature branch merge or direct **only when Nick approves in chat**)
 - `feature/*` branches
 - Customer production (`main`, HSD `production`) **only** after [`production-merge.md`](../../references/agent-session/production-merge.md): human **asked** in this conversation, agent **restated** the exact merge (site, branches, publishes production), human **confirmed** with a second yes. cms-edit host diffs also need [`cms-edit-prod-merge.md`](../../references/agent-session/cms-edit-prod-merge.md).
+- **se-core-product** `main` **only** after the same ask + confirm gate: restate repo = se-core-product, `dev` → `main`, and that Release Main **publishes npm** (and may deploy anything on `main`); wait for a second **yes**. Also post `## Merge approval` on the promote PR.
 
 Do **not** wait for or require a `nick-go` GitHub label.
 
-Agents must **never** push **se-core-product** `main`. Agents must **never** ship from a registry `productionPath` (e.g. HSD `~/source/customers/hopskipdrive/production-hsd-website`). Opening a production PR is not a merge.
+Agents must **never** ship from a registry `productionPath` (e.g. HSD `~/source/customers/hopskipdrive/production-hsd-website`). Opening a production or core `main` PR is not a merge.
 
 **Preferred:** open a **draft PR** targeting the integration branch (this is how cloud + other laptops see the work):
 
@@ -313,6 +324,8 @@ If `gh` is unavailable or user prefers direct push, push `feature/*` and note th
 
 When **marketing** work is ready for production, **stop** and hand off. Do **not** merge `develop` → production unless [`production-merge.md`](../../references/agent-session/production-merge.md) passed in this conversation (ask + restatement + second yes). One customer repo at a time. cms-edit host extra gate: [`cms-edit-prod-merge.md`](../../references/agent-session/cms-edit-prod-merge.md).
 
+When the promote depends on new/changed Contentful content, also complete [`release-verification.md`](../../references/agent-session/release-verification.md) (publish state, content smoke, preview compare). A Nick override never skips publish-state or content smoke.
+
 Deliver handoff using the template below. If a core release was part of the work, list published package versions needed for the customer bump.
 
 ### Handoff template
@@ -341,8 +354,8 @@ Deliver handoff using the template below. If a core release was part of the work
 2. <customer pnpm update @se-studio/...>
 3. <customer PR>
 
-### Production
-Do not merge until the human asks **and** confirms (`production-merge.md`). Not `productionPath`, not `vercel deploy`. se-core-product `main`: never agent.
+### Production / core main
+Do not merge until the human asks **and** confirms (`production-merge.md`). Not `productionPath`, not `vercel deploy`. se-core-product `dev` → `main`: same ask + confirm (publishes npm).
 ```
 
 ---
@@ -351,7 +364,7 @@ Do not merge until the human asks **and** confirms (`production-merge.md`). Not
 
 | Outcome | Action |
 |---------|--------|
-| Merged / done | Remove the **local** worktree if you created one; the PR close is the record |
+| Merged / done | Remove the **local** worktree if you created one; the PR close is the record. Run fleet-status again and deal with anything it still lists |
 | Parked | Leave the branch + draft PR; say why in chat |
 
 ```bash
@@ -372,7 +385,7 @@ Feature: hero-redesign
 Branch: feature/om1/hero-redesign
 ```
 
-Agent must load this skill, run placement checklist, create a **local** worktree (or use the cloud checkout), then proceed. **Do not** write `work/active/*.yaml`.
+Agent must load this skill, run fleet-status, run the placement checklist, create a **local** worktree (or use the cloud checkout), then proceed. **Do not** write `work/active/*.yaml`.
 
 ---
 
@@ -388,6 +401,6 @@ Agent must load this skill, run placement checklist, create a **local** worktree
 | `pedestal` | `develop` | `main` | customer monorepo |
 | `hsd` | `develop` (`develop-hsd-website`) | `production` (`production-hsd-website`) | customer |
 | `highlander` | `develop` | `main` | customer |
-| `eagle` | `main` (until `develop` exists) | `main` | customer |
+| `eagle` | `develop` | `main` | customer |
 
 Full paths (`path`, `worktreesRoot`, `productionPath`), MCP keys: `projects.registry.json`.

package/skills/tdd/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: tdd
+description: "Use only when the user explicitly asks for TDD, a failing test, or a regression test, OR when the bug has an obvious cheap local test target. Skip when the test path is unclear, expensive, integration-heavy, or not requested."
+---
+
+# TDD Bug Fix
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+When fixing a bug with a clear, cheap test path, make the broken behavior executable before changing production code. The goal is a focused regression test that fails before the fix and passes after it.
+
+Do not force a test when it would be impractical. If the available test would require broad harness setup, brittle mocks, slow end-to-end infrastructure, production-only state, vague reproduction steps, or large unrelated fixture churn, skip adding a new test and use the closest useful verification instead.
+
+## Workflow
+
+1. **Understand the bug.** Identify the intended behavior, current behavior, affected path, and smallest observable reproduction.
+2. **Choose the narrowest executable check.** Prefer the closest unit, component, integration, or regression test already used for that codepath. If no practical test path is obvious, do not create one from scratch just to satisfy the workflow.
+3. **Write the failing test first.** Add the smallest focused test that would have caught the bug. The test should encode intended behavior, not mirror the current implementation.
+4. **Run the new test before fixing.** Confirm it fails for the intended reason. If it passes or fails for an unrelated reason, correct the test or reproduction before editing the implementation.
+5. **Fix the bug.** Make the smallest production change that satisfies the intended behavior while preserving nearby contracts.
+6. **Rerun the regression test.** Confirm the test now passes.
+
+## If a Failing Test Is Impractical
+
+Use the closest executable regression check instead: a targeted script, manual reproduction command, browser automation, snapshot comparison, log assertion, or focused integration check.
+
+Prefer no new test over a bad test. A bad test is one that mostly tests mocks, encodes current implementation details, depends on timing or unrelated global state, needs expensive infrastructure for a small fix, or would be deleted immediately after proving the fix.
+
+## Guardrails
+
+- Do not change tests merely to match a wrong implementation.
+- Do not weaken existing assertions unless the expected behavior has genuinely changed and the reason is clear.
+- Keep the regression test focused on the bug. Avoid broad fixture churn or unrelated coverage expansion.
+- If the bug is flaky, make the test deterministic where possible and document the signal being locked down.
+- If the bug exposes a broader class of failures, first land the focused regression path, then consider additional sibling coverage.
+
+## Final Response
+
+Report the evidence, not just the outcome:
+
+- Name the failing-before test or executable check and the failure it produced.
+- Name the passing-after test run and any nearby validation performed.
+- If failing-before evidence could not be demonstrated, state why and describe the closest regression check used instead.

package/skills/typescript-best-practices/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: typescript-best-practices
+description: "TypeScript best practices. Use when reading or editing any .ts or .tsx file."
+---
+
+# TypeScript best practices
+
+
+## SE Studio vendoring notes
+
+- Upstream frontmatter `paths: ["**/*.ts", "**/*.tsx"]` moved out of YAML (SE Studio skills allow only name + description).
+- Upstream frontmatter `disable-model-invocation: true` moved out of YAML (SE Studio skills allow only name + description).
+
+Apply the **type-system-discipline** principle skill first.
+
+| Rule | Summary |
+|------|---------|
+| Discriminated unions | Model variants with a `kind` literal discriminant so impossible states can't be represented. No optional-field bags. |
+| Branded types | Brand primitives with `& { readonly __brand: "X" }` so they can't be mixed up. Validate once at the boundary. |
+| Constructive modeling | Build the shape so the illegal value can't be constructed. `[T, ...T[]]` for non-empty, `[T, T][]` for even length, `start` plus `duration` for a range. Not a runtime guard, not a wish for refinement types. |
+| Simplest total type | Keep `T[]` while every operation on it stays total. Strengthen to `NonEmpty<T>` only where the loose type forces `!`, a cast, or a "should never happen" throw. |
+| `unknown` over `any` | External data is `unknown`. |
+| Schemas before guards | Before hand-writing a property-by-property type guard, use the repository's runtime schema library and infer the type from the schema, such as `z.infer`. |
+| No `as` casts | Every `as` is a runtime crash waiting. Cast only after validation. |
+| Narrowing hierarchy | Discriminant switch > `in` operator > `typeof`/`instanceof` > user-defined type guard > `as`. |
+| Type guards | Must verify the claim. A lying guard is worse than `as` because the bug hides behind a name that says it's safe. Name them `isX` or `hasX`. |
+| Exhaustiveness | Inline `const _exhaustive: never = x;` in default arms so the compiler errors when a new variant is added. |
+| `satisfies` over `as` | Validates the value without widening literal types. |
+| Boundary validation | Parse where data crosses in, into a named domain type. `Record<string, unknown>` (however spelled) stops at that parse. Trust types inside. See the **boundary-discipline** principle skill. |
+| Schema-derived types | Reach for `Pick`/`Omit`/`Parameters`/`ReturnType`/`Awaited`/`typeof` before declaring a new interface. |
+| Object args | Pass objects, not positional, so argument order is self-documenting. Skip on hot paths (per-frame render, tokenizers, parsers). |
+| Real tests | Don't mock what you can run. Prefer the framework's real test primitives with leak/disposable checks, and verify UI in a running build. Mock only what you can't run locally. |
+| Structured telemetry | Prefer structured logger diagnostics with enough context to debug from an id. No `console.log` in shipped code. |
+
+Examples: `references/patterns.md`.