@baselane/packs 0.1.0

package/packs/systematic-debugging/pack.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://baselane.dev/schema/workflow-pack-v1.json",
+  "id": "systematic-debugging",
+  "version": "1.1.0",
+  "title": "Systematic debugging",
+  "summary": "Root cause before fix: a four-phase debugging discipline governed by the Iron Law, escalating to an architectural review after three failed attempts instead of a fourth guess. The same discipline also ships as the \"systematic-debugging\" seed skill in the skills library — adopting both is redundant, not complementary; pick this pack for the enforcing subagent/hooks or the skill for zero-setup guidance.",
+  "scope": "both",
+  "attribution": { "source": "obra/superpowers", "url": "https://github.com/obra/superpowers", "license": "MIT" },
+  "context": {
+    "markdown": "## Systematic debugging\n\n- The Iron Law: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST. If you have not found the root cause, you may not propose a fix.\n- Work the four phases in order: (1) root-cause investigation, (2) pattern analysis, (3) hypothesis and testing, (4) implementation.\n- After three failed fix attempts, STOP — the architecture is suspect. Do not attempt a fourth fix without an explicit architectural discussion.\n"
+  },
+  "agents": [
+    {
+      "name": "debugger",
+      "description": "Phase-disciplined investigator that reports an evidence chain from symptom to cause, not a guess.",
+      "tools": ["Read", "Grep", "Glob", "Bash"],
+      "model": "sonnet",
+      "prompt": "You are a systematic debugger. Obey the Iron Law: do not propose a fix until you have found the root cause. Reproduce the failure first, then work the four phases in order — root-cause investigation, pattern analysis, hypothesis and testing, implementation. Report the evidence chain from symptom to cause with file:line references, and never present a hypothesis as a conclusion. If three fixes have already failed, stop and recommend an architectural review instead of attempting a fourth."
+    }
+  ],
+  "commands": [
+    {
+      "name": "debug",
+      "description": "Walk a bug through the four phases; refuse to patch before the root cause is found.",
+      "argument_hint": "[symptom]",
+      "prompt": "Investigate $ARGUMENTS through the four phases in order — root-cause investigation, pattern analysis, hypothesis and testing, then implementation. Do not propose or apply a fix until the root cause is identified with evidence. If three fixes have already failed, stop and raise the architecture for discussion instead of trying a fourth."
+    },
+    {
+      "name": "root-cause",
+      "description": "Trace a symptom back to its origin before any change.",
+      "argument_hint": "[symptom or failing test]",
+      "prompt": "Trace $ARGUMENTS backwards from the observed symptom to its origin: reproduce it, follow the data and control flow to the first point where reality diverges from intent, and state the root cause with the evidence chain that proves it — before proposing any change."
+    }
+  ],
+  "hooks": [
+    {
+      "event": "PostToolUse",
+      "matcher": "Edit|Write",
+      "description": "After an edit, nudge the root-cause-before-fix discipline.",
+      "action": "print-reminder",
+      "message": "Root cause before fix: is this change addressing the cause you proved, or patching a symptom?"
+    }
+  ]
+}

package/packs/systematic-debugging/rendered/.claude/agents/debugger.md

@@ -0,0 +1,8 @@
+---
+name: debugger
+description: Phase-disciplined investigator that reports an evidence chain from symptom to cause, not a guess.
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+You are a systematic debugger. Obey the Iron Law: do not propose a fix until you have found the root cause. Reproduce the failure first, then work the four phases in order — root-cause investigation, pattern analysis, hypothesis and testing, implementation. Report the evidence chain from symptom to cause with file:line references, and never present a hypothesis as a conclusion. If three fixes have already failed, stop and recommend an architectural review instead of attempting a fourth.

package/packs/systematic-debugging/rendered/.claude/commands/debug.md

@@ -0,0 +1,6 @@
+---
+description: Walk a bug through the four phases; refuse to patch before the root cause is found.
+argument-hint: [symptom]
+---
+
+Investigate $ARGUMENTS through the four phases in order — root-cause investigation, pattern analysis, hypothesis and testing, then implementation. Do not propose or apply a fix until the root cause is identified with evidence. If three fixes have already failed, stop and raise the architecture for discussion instead of trying a fourth.

package/packs/systematic-debugging/rendered/.claude/commands/root-cause.md

@@ -0,0 +1,6 @@
+---
+description: Trace a symptom back to its origin before any change.
+argument-hint: [symptom or failing test]
+---
+
+Trace $ARGUMENTS backwards from the observed symptom to its origin: reproduce it, follow the data and control flow to the first point where reality diverges from intent, and state the root cause with the evidence chain that proves it — before proposing any change.

package/packs/systematic-debugging/rendered/.claude/settings.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo \"Root cause before fix: is this change addressing the cause you proved, or patching a symptom?\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/packs/systematic-debugging/rendered/.github/copilot-instructions.md

@@ -0,0 +1,20 @@
+# Copilot instructions
+
+## Systematic debugging
+
+- The Iron Law: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST. If you have not found the root cause, you may not propose a fix.
+- Work the four phases in order: (1) root-cause investigation, (2) pattern analysis, (3) hypothesis and testing, (4) implementation.
+- After three failed fix attempts, STOP — the architecture is suspect. Do not attempt a fourth fix without an explicit architectural discussion.
+
+## Workflow pack: Systematic debugging
+
+Root cause before fix: a four-phase debugging discipline governed by the Iron Law, escalating to an architectural review after three failed attempts instead of a fourth guess. The same discipline also ships as the "systematic-debugging" seed skill in the skills library — adopting both is redundant, not complementary; pick this pack for the enforcing subagent/hooks or the skill for zero-setup guidance.
+
+When acting as the debugger role: You are a systematic debugger. Obey the Iron Law: do not propose a fix until you have found the root cause. Reproduce the failure first, then work the four phases in order — root-cause investigation, pattern analysis, hypothesis and testing, implementation. Report the evidence chain from symptom to cause with file:line references, and never present a hypothesis as a conclusion. If three fixes have already failed, stop and recommend an architectural review instead of attempting a fourth.
+
+Workflow steps:
+
+- debug: Investigate $ARGUMENTS through the four phases in order — root-cause investigation, pattern analysis, hypothesis and testing, then implementation. Do not propose or apply a fix until the root cause is identified with evidence. If three fixes have already failed, stop and raise the architecture for discussion instead of trying a fourth.
+- root-cause: Trace $ARGUMENTS backwards from the observed symptom to its origin: reproduce it, follow the data and control flow to the first point where reality diverges from intent, and state the root cause with the evidence chain that proves it — before proposing any change.
+
+- Root cause before fix: is this change addressing the cause you proved, or patching a symptom?

package/packs/systematic-debugging/rendered/AGENTS.md

@@ -0,0 +1,31 @@
+# AGENTS.md
+
+<!-- generated from workflow-pack systematic-debugging v1.1.0 -->
+<!-- adapted from obra/superpowers (MIT) — https://github.com/obra/superpowers -->
+
+## Systematic debugging
+
+- The Iron Law: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST. If you have not found the root cause, you may not propose a fix.
+- Work the four phases in order: (1) root-cause investigation, (2) pattern analysis, (3) hypothesis and testing, (4) implementation.
+- After three failed fix attempts, STOP — the architecture is suspect. Do not attempt a fourth fix without an explicit architectural discussion.
+
+## Workflow pack: Systematic debugging
+
+Root cause before fix: a four-phase debugging discipline governed by the Iron Law, escalating to an architectural review after three failed attempts instead of a fourth guess. The same discipline also ships as the "systematic-debugging" seed skill in the skills library — adopting both is redundant, not complementary; pick this pack for the enforcing subagent/hooks or the skill for zero-setup guidance.
+
+### Roles
+
+- **debugger** — Phase-disciplined investigator that reports an evidence chain from symptom to cause, not a guess.
+
+### Commands
+
+- **/debug** `[symptom]` — Walk a bug through the four phases; refuse to patch before the root cause is found.
+  - How it runs: Investigate $ARGUMENTS through the four phases in order — root-cause investigation, pattern analysis, hypothesis and testing, then implementation. Do not propose or apply a fix until the root cause is identified with evidence. If three fixes have already failed, stop and raise the architecture for discussion instead of trying a fourth.
+- **/root-cause** `[symptom or failing test]` — Trace a symptom back to its origin before any change.
+  - How it runs: Trace $ARGUMENTS backwards from the observed symptom to its origin: reproduce it, follow the data and control flow to the first point where reality diverges from intent, and state the root cause with the evidence chain that proves it — before proposing any change.
+
+### Guardrails
+
+- After an edit, nudge the root-cause-before-fix discipline.
+
+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/systematic-debugging/rendered/CLAUDE.md

@@ -0,0 +1,9 @@
+# CLAUDE.md
+
+@AGENTS.md
+
+This project defines a native Claude Code implementation of this workflow pack:
+- Subagent: `.claude/agents/debugger.md`
+- Command: `.claude/commands/debug.md`
+- Command: `.claude/commands/root-cause.md`
+- Hooks: see `.claude/settings.json`

package/packs/systematic-debugging/rendered/GEMINI.md

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

package/packs/token-efficiency-harness/pack.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "https://baselane.dev/schema/workflow-pack-v1.json",
+  "id": "token-efficiency-harness",
+  "version": "1.2.0",
+  "title": "Token-efficiency harness",
+  "summary": "Keeps per-turn context small: one task per session, model tiering, capped thinking, and budgeted autonomous runs — the habits that keep token spend down without cutting output.",
+  "scope": "both",
+  "context": {
+    "markdown": "## Token-efficiency discipline\n\nEach turn re-sends the whole session, so keep it small:\n\n- **One task, one session.** When a task is done, `/clear`. For genuinely long tasks, `/compact` at milestones (after a feature lands, never mid-debug).\n- **Hand off instead of continuing.** End multi-day work by writing a handoff note into repo memory (`/handoff`), then start tomorrow clean from that note.\n- **Tier your models.** The main conversation gets the best model; search, mechanical edits, and fan-out go to cheaper subagents. Five parallel top-tier agents burn five times the rate.\n- **Cap extended thinking** for routine work (`MAX_THINKING_TOKENS=10000`); raise it only for genuinely hard problems.\n- **Specific beats short.** One precise sentence replaces three exploratory rounds. Grep logs first and paste the 10 relevant lines, never the 500-line dump — a paste is re-sent on every following turn.\n- **Work in bursts.** The prompt cache expires after a few idle minutes; rapid-fire turns replay history cheaply, sporadic drips rebuild it at full price.\n- **Budget every autonomous run.** State a token budget and a definition of done, and require a diff summary plus self-review at the end so a stuck loop cannot retry forever.\n"
+  },
+  "agents": [
+    {
+      "name": "scout",
+      "description": "Cheap, fast reconnaissance: finds files, symbols, and usage sites and returns file:line references — never full file dumps. Use for any search or lookup before involving the main model.",
+      "tools": ["Read", "Grep", "Glob", "Bash"],
+      "model": "haiku",
+      "prompt": "You are a scout. Locate what was asked for (files, symbols, call sites, config values) as quickly and cheaply as possible. Return findings as a short list of file:line references with a one-line note each. Do not paste file contents unless a specific excerpt was requested, and never more than 10 lines of it."
+    }
+  ],
+  "commands": [
+    {
+      "name": "handoff",
+      "description": "End the session with a durable handoff note in memory so the next session starts clean and cheap.",
+      "argument_hint": "[note-name]",
+      "prompt": "Write a durable handoff note under `.baselane/memory/` — a new fact file with `name`/`description` frontmatter plus a line in `.baselane/memory/MEMORY.md` — covering what was completed (with commit hashes), what remains, key files and decisions, and the exact next step. Keep it under 40 lines, then tell the user to /clear and resume from memory next session."
+    },
+    {
+      "name": "usage-audit",
+      "description": "Audit local Claude Code token usage and recommend the highest-impact fix.",
+      "argument_hint": "[optional]",
+      "prompt": "Run `npx ccusage@latest` via Bash and read the breakdown. Report: the top model by tokens, cache-read volume versus fresh input, and the single highest-impact change from the token-efficiency rules in AGENTS.md (session hygiene, model tiering, thinking cap, or run budgets). End with one concrete habit change for this user."
+    }
+  ],
+  "hooks": [
+    {
+      "event": "PostToolUse",
+      "matcher": "Task",
+      "description": "Remind about model tiering whenever a subagent is spawned.",
+      "action": "print-reminder",
+      "message": "Tier your subagents: search/mechanical work runs on haiku or sonnet — reserve the top model for the main loop."
+    }
+  ],
+  "onboarding": [
+    { "id": "init-memory", "title": "Initialize the memory directory", "description": "Create .baselane/memory/ for persistent agent memory.", "command": "baselane memory init" }
+  ],
+  "capabilities": [
+    { "type": "memory", "store": "repo", "method": "files" }
+  ]
+}

package/packs/token-efficiency-harness/rendered/.baselane/capabilities.json

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

package/packs/token-efficiency-harness/rendered/.baselane/memory/README.md

@@ -0,0 +1,34 @@
+# Memory protocol
+
+This directory holds durable facts the AI has learned while working on this project —
+one fact per file, plus an index. Consult the index before acting; add a fact after
+learning something durable (a decision, a correction, a constraint that isn't obvious
+from the code).
+
+## Format
+
+Each fact is a single markdown file with simple frontmatter:
+
+```markdown
+---
+name: <short-kebab-case-slug>
+description: <one-line summary — used to decide relevance during recall>
+---
+
+<the fact, in a sentence or two.>
+```
+
+## Index
+
+`MEMORY.md` in this directory lists every fact, one line per file, so the index alone
+can be scanned without opening each one:
+
+```markdown
+- [Title](file.md) — one-line hook
+```
+
+## Rule
+
+- Consult `MEMORY.md` before acting — recall what's already known.
+- After learning something durable, write a new fact file and add a line to
+  `MEMORY.md`. Use `/remember <fact>` to do both in one step.

package/packs/token-efficiency-harness/rendered/.claude/agents/scout.md

@@ -0,0 +1,8 @@
+---
+name: scout
+description: Cheap, fast reconnaissance: finds files, symbols, and usage sites and returns file:line references — never full file dumps. Use for any search or lookup before involving the main model.
+tools: Read, Grep, Glob, Bash
+model: haiku
+---
+
+You are a scout. Locate what was asked for (files, symbols, call sites, config values) as quickly and cheaply as possible. Return findings as a short list of file:line references with a one-line note each. Do not paste file contents unless a specific excerpt was requested, and never more than 10 lines of it.

package/packs/token-efficiency-harness/rendered/.claude/commands/handoff.md

@@ -0,0 +1,6 @@
+---
+description: End the session with a durable handoff note in memory so the next session starts clean and cheap.
+argument-hint: [note-name]
+---
+
+Write a durable handoff note under `.baselane/memory/` — a new fact file with `name`/`description` frontmatter plus a line in `.baselane/memory/MEMORY.md` — covering what was completed (with commit hashes), what remains, key files and decisions, and the exact next step. Keep it under 40 lines, then tell the user to /clear and resume from memory next session.

package/packs/token-efficiency-harness/rendered/.claude/commands/remember.md

@@ -0,0 +1,6 @@
+---
+description: Append a durable fact to .baselane/memory/ and update its index.
+argument-hint: <fact>
+---
+
+Write $ARGUMENTS as a new fact file under `.baselane/memory/` (kebab-case name, frontmatter with `name` and `description`, then the fact itself). Then add a one-line entry for it to `.baselane/memory/MEMORY.md` (create the index if it doesn't exist yet). Keep the fact to one durable, non-obvious sentence or two.

package/packs/token-efficiency-harness/rendered/.claude/commands/usage-audit.md

@@ -0,0 +1,6 @@
+---
+description: Audit local Claude Code token usage and recommend the highest-impact fix.
+argument-hint: [optional]
+---
+
+Run `npx ccusage@latest` via Bash and read the breakdown. Report: the top model by tokens, cache-read volume versus fresh input, and the single highest-impact change from the token-efficiency rules in AGENTS.md (session hygiene, model tiering, thinking cap, or run budgets). End with one concrete habit change for this user.

package/packs/token-efficiency-harness/rendered/.claude/settings.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo \"Tier your subagents: search/mechanical work runs on haiku or sonnet — reserve the top model for the main loop.\""
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo \"Before finishing, capture any durable decisions or facts from this session to .baselane/memory/ (use /remember) and update its MEMORY.md index.\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/packs/token-efficiency-harness/rendered/.github/copilot-instructions.md

@@ -0,0 +1,26 @@
+# Copilot instructions
+
+## Token-efficiency discipline
+
+Each turn re-sends the whole session, so keep it small:
+
+- **One task, one session.** When a task is done, `/clear`. For genuinely long tasks, `/compact` at milestones (after a feature lands, never mid-debug).
+- **Hand off instead of continuing.** End multi-day work by writing a handoff note into repo memory (`/handoff`), then start tomorrow clean from that note.
+- **Tier your models.** The main conversation gets the best model; search, mechanical edits, and fan-out go to cheaper subagents. Five parallel top-tier agents burn five times the rate.
+- **Cap extended thinking** for routine work (`MAX_THINKING_TOKENS=10000`); raise it only for genuinely hard problems.
+- **Specific beats short.** One precise sentence replaces three exploratory rounds. Grep logs first and paste the 10 relevant lines, never the 500-line dump — a paste is re-sent on every following turn.
+- **Work in bursts.** The prompt cache expires after a few idle minutes; rapid-fire turns replay history cheaply, sporadic drips rebuild it at full price.
+- **Budget every autonomous run.** State a token budget and a definition of done, and require a diff summary plus self-review at the end so a stuck loop cannot retry forever.
+
+## Workflow pack: Token-efficiency harness
+
+Keeps per-turn context small: one task per session, model tiering, capped thinking, and budgeted autonomous runs — the habits that keep token spend down without cutting output.
+
+When acting as the scout role: You are a scout. Locate what was asked for (files, symbols, call sites, config values) as quickly and cheaply as possible. Return findings as a short list of file:line references with a one-line note each. Do not paste file contents unless a specific excerpt was requested, and never more than 10 lines of it.
+
+Workflow steps:
+
+- handoff: Write a durable handoff note under `.baselane/memory/` — a new fact file with `name`/`description` frontmatter plus a line in `.baselane/memory/MEMORY.md` — covering what was completed (with commit hashes), what remains, key files and decisions, and the exact next step. Keep it under 40 lines, then tell the user to /clear and resume from memory next session.
+- usage-audit: Run `npx ccusage@latest` via Bash and read the breakdown. Report: the top model by tokens, cache-read volume versus fresh input, and the single highest-impact change from the token-efficiency rules in AGENTS.md (session hygiene, model tiering, thinking cap, or run budgets). End with one concrete habit change for this user.
+
+- Tier your subagents: search/mechanical work runs on haiku or sonnet — reserve the top model for the main loop.

package/packs/token-efficiency-harness/rendered/AGENTS.md

@@ -0,0 +1,44 @@
+# AGENTS.md
+
+<!-- generated from workflow-pack token-efficiency-harness v1.2.0 -->
+
+## Token-efficiency discipline
+
+Each turn re-sends the whole session, so keep it small:
+
+- **One task, one session.** When a task is done, `/clear`. For genuinely long tasks, `/compact` at milestones (after a feature lands, never mid-debug).
+- **Hand off instead of continuing.** End multi-day work by writing a handoff note into repo memory (`/handoff`), then start tomorrow clean from that note.
+- **Tier your models.** The main conversation gets the best model; search, mechanical edits, and fan-out go to cheaper subagents. Five parallel top-tier agents burn five times the rate.
+- **Cap extended thinking** for routine work (`MAX_THINKING_TOKENS=10000`); raise it only for genuinely hard problems.
+- **Specific beats short.** One precise sentence replaces three exploratory rounds. Grep logs first and paste the 10 relevant lines, never the 500-line dump — a paste is re-sent on every following turn.
+- **Work in bursts.** The prompt cache expires after a few idle minutes; rapid-fire turns replay history cheaply, sporadic drips rebuild it at full price.
+- **Budget every autonomous run.** State a token budget and a definition of done, and require a diff summary plus self-review at the end so a stuck loop cannot retry forever.
+
+## Harness capabilities
+
+- memory · repo · files — provisioned
+
+### Memory
+
+Consult `.baselane/memory/` and its `MEMORY.md` index before acting — it holds durable facts from past sessions. Use `/remember` to add one after learning something durable.
+
+## Workflow pack: Token-efficiency harness
+
+Keeps per-turn context small: one task per session, model tiering, capped thinking, and budgeted autonomous runs — the habits that keep token spend down without cutting output.
+
+### Roles
+
+- **scout** — Cheap, fast reconnaissance: finds files, symbols, and usage sites and returns file:line references — never full file dumps. Use for any search or lookup before involving the main model.
+
+### Commands
+
+- **/handoff** `[note-name]` — End the session with a durable handoff note in memory so the next session starts clean and cheap.
+  - How it runs: Write a durable handoff note under `.baselane/memory/` — a new fact file with `name`/`description` frontmatter plus a line in `.baselane/memory/MEMORY.md` — covering what was completed (with commit hashes), what remains, key files and decisions, and the exact next step. Keep it under 40 lines, then tell the user to /clear and resume from memory next session.
+- **/usage-audit** `[optional]` — Audit local Claude Code token usage and recommend the highest-impact fix.
+  - How it runs: Run `npx ccusage@latest` via Bash and read the breakdown. Report: the top model by tokens, cache-read volume versus fresh input, and the single highest-impact change from the token-efficiency rules in AGENTS.md (session hygiene, model tiering, thinking cap, or run budgets). End with one concrete habit change for this user.
+
+### Guardrails
+
+- Remind about model tiering whenever a subagent is spawned.
+
+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/token-efficiency-harness/rendered/CLAUDE.md

@@ -0,0 +1,10 @@
+# CLAUDE.md
+
+@AGENTS.md
+
+This project defines a native Claude Code implementation of this workflow pack:
+- Subagent: `.claude/agents/scout.md`
+- Command: `.claude/commands/handoff.md`
+- Command: `.claude/commands/usage-audit.md`
+- Command: `.claude/commands/remember.md`
+- Hooks: see `.claude/settings.json`

package/packs/token-efficiency-harness/rendered/GEMINI.md

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

package/packs/typescript-rules/pack.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://baselane.dev/schema/workflow-pack-v1.json",
+  "id": "typescript-rules",
+  "version": "1.4.0",
+  "title": "TypeScript rules",
+  "summary": "TypeScript conventions a linter can't check — explicit public-API types, unknown over any with narrowing, immutable updates, Zod at the boundary — with a reviewer and a prettier guard; formatting and lint rules belong in CI.",
+  "scope": "repo",
+  "attribution": { "source": "affaan-m/ECC", "url": "https://github.com/affaan-m/ECC", "license": "MIT" },
+  "context": {
+    "markdown": "## TypeScript/JavaScript conventions (beyond what the linter enforces)\n\n`eslint` and `prettier` already enforce formatting, `no-explicit-any`, and stray `console.log` — this pack is the judgment they can't encode. Keep the mechanical checks in CI (`prettier --check .`, `eslint .`); the reviewer covers the rest.\n\n### Types at the surface\n\n- Give exported functions, shared utilities, and public methods explicit parameter and return types; let inference handle obvious locals.\n- Use `interface` for object shapes meant to be extended; use `type` for unions, intersections, and mapped types. Prefer string-literal unions over `enum` unless interop demands one.\n- Use `unknown` for external/untrusted input and narrow it before use (`error instanceof Error`); reserve `any` for genuine escape hatches, never as the default.\n- Type React props with a named `interface`/`type` and type callback props explicitly; skip `React.FC` unless you need it.\n\n### Immutability\n\n- Return new objects/arrays via spread (`{ ...user, name }`) or `map`/`filter` — never `push`/`splice`/assignment on a value you received.\n\n### Errors and boundaries\n\n- Handle errors explicitly with context, then re-raise or return a typed error; narrow an `unknown` caught error before reading `.message`.\n- Validate external input at the boundary with a schema (e.g. Zod) and infer the type from the schema rather than hand-writing both.\n- Read required secrets from the environment and fail fast at startup if one is missing.\n\n### Flag in review (a linter won't)\n\n- An exported function with no parameter/return types.\n- `any` where `unknown` plus a type guard would do.\n- In-place mutation of a function argument.\n- A repeated inline object shape that should be a named type.\n"
+  },
+  "skills": [
+    {
+      "name": "immutable-updates",
+      "description": "Use when updating objects, arrays, or records in application code — return a new copy with the change applied instead of mutating the original in place, to prevent hidden side effects and aliasing bugs.",
+      "body": "# Immutable updates\n\nWhen you change a value, **produce a new copy — never mutate the argument you were handed.** Shared\nreferences mean an in-place mutation is a spooky-action-at-a-distance bug: some other holder of the\nsame object sees a change it never asked for.\n\n```ts\n// WRONG — mutates the caller's object\nfunction rename(user, name) {\n  user.name = name;\n  return user;\n}\n\n// CORRECT — returns a new object, original untouched\nfunction rename(user, name) {\n  return { ...user, name };\n}\n```\n\n## Patterns\n\n- **Object field:** `{ ...obj, field: value }`.\n- **Nested field:** spread each level you touch — `{ ...obj, addr: { ...obj.addr, city } }`.\n- **Array append/remove:** `[...list, item]`, `list.filter(x => x.id !== id)`,\n  `list.map(x => x.id === id ? { ...x, done: true } : x)` — not `push`/`splice`/index assignment.\n- **Record update:** `{ ...map, [key]: value }` and `const { [key]: _drop, ...rest } = map` to remove.\n\n## Why it pays off\n\n- **No hidden side effects.** A function that returns a new value can't corrupt state its caller\n  still depends on. Behavior is a function of inputs, not of call order.\n- **Debugging is local.** When a value is wrong, the mutation that produced it is the expression\n  that built it — not some distant `.sort()` or field write on a shared reference.\n- **Safe concurrency and change-detection.** Referential equality (`prev !== next`) becomes a\n  reliable \"did this change?\" signal for caches, memoization, and UI diffing.\n\n## When in-place is acceptable\n\nA locally-scoped object that never escapes the function — a builder/accumulator you allocated and\nreturn once — is fine to mutate. The rule protects values that are *shared*: arguments, fields on\nlong-lived state, anything another holder still references.\n",
+      "category": "write"
+    }
+  ],
+  "agents": [
+    {
+      "name": "typescript-reviewer",
+      "description": "Reviews changed TypeScript/JavaScript against the standards: explicit public-API types, unknown over any, immutable updates, Zod boundaries, and env-var secrets. Reports file:line + severity. Use after any TS/JS change.",
+      "tools": ["Read", "Grep", "Glob", "Bash"],
+      "model": "sonnet",
+      "prompt": "You are a TypeScript reviewer. Read the changed TS/JS files and check them against the conventions in context: explicit types on exported/public APIs, `unknown` over `any` with narrowing, immutable updates via spread/array methods, typed error handling, boundary validation with a schema library, and env-var secrets that fail fast. Formatting and lint rules 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": "typescript-review",
+      "description": "Run the TypeScript reviewer over the current change against this pack's TypeScript standards.",
+      "argument_hint": "[base ref]",
+      "prompt": "Invoke the typescript-reviewer subagent on the changed TypeScript files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — explicit public-API types, unknown over any with narrowing, immutable updates, and Zod at the boundary — and reports file:line + severity. Formatting and lint rules 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 formatting with prettier when it is installed.",
+      "action": "run-command",
+      "command": "if command -v prettier >/dev/null 2>&1; then prettier --check .; else echo \"prettier not found — install prettier to check formatting (typescript-rules)\"; fi"
+    }
+  ]
+}

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

@@ -0,0 +1,8 @@
+---
+name: typescript-reviewer
+description: Reviews changed TypeScript/JavaScript against the standards: explicit public-API types, unknown over any, immutable updates, Zod boundaries, and env-var secrets. Reports file:line + severity. Use after any TS/JS change.
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+You are a TypeScript reviewer. Read the changed TS/JS files and check them against the conventions in context: explicit types on exported/public APIs, `unknown` over `any` with narrowing, immutable updates via spread/array methods, typed error handling, boundary validation with a schema library, and env-var secrets that fail fast. Formatting and lint rules 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/typescript-rules/rendered/.claude/commands/typescript-review.md

@@ -0,0 +1,6 @@
+---
+description: Run the TypeScript reviewer over the current change against this pack's TypeScript standards.
+argument-hint: [base ref]
+---
+
+Invoke the typescript-reviewer subagent on the changed TypeScript files (the diff since $ARGUMENTS, or the working tree if no ref is given). It checks this pack's conventions — explicit public-API types, unknown over any with narrowing, immutable updates, and Zod at the boundary — and reports file:line + severity. Formatting and lint rules are CI's job; don't re-litigate them. Fix any Critical or Important findings before merging.

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

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

package/packs/typescript-rules/rendered/.claude/skills/immutable-updates/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: immutable-updates
+description: Use when updating objects, arrays, or records in application code — return a new copy with the change applied instead of mutating the original in place, to prevent hidden side effects and aliasing bugs.
+---
+
+# Immutable updates
+
+When you change a value, **produce a new copy — never mutate the argument you were handed.** Shared
+references mean an in-place mutation is a spooky-action-at-a-distance bug: some other holder of the
+same object sees a change it never asked for.
+
+```ts
+// WRONG — mutates the caller's object
+function rename(user, name) {
+  user.name = name;
+  return user;
+}
+
+// CORRECT — returns a new object, original untouched
+function rename(user, name) {
+  return { ...user, name };
+}
+```
+
+## Patterns
+
+- **Object field:** `{ ...obj, field: value }`.
+- **Nested field:** spread each level you touch — `{ ...obj, addr: { ...obj.addr, city } }`.
+- **Array append/remove:** `[...list, item]`, `list.filter(x => x.id !== id)`,
+  `list.map(x => x.id === id ? { ...x, done: true } : x)` — not `push`/`splice`/index assignment.
+- **Record update:** `{ ...map, [key]: value }` and `const { [key]: _drop, ...rest } = map` to remove.
+
+## Why it pays off
+
+- **No hidden side effects.** A function that returns a new value can't corrupt state its caller
+  still depends on. Behavior is a function of inputs, not of call order.
+- **Debugging is local.** When a value is wrong, the mutation that produced it is the expression
+  that built it — not some distant `.sort()` or field write on a shared reference.
+- **Safe concurrency and change-detection.** Referential equality (`prev !== next`) becomes a
+  reliable "did this change?" signal for caches, memoization, and UI diffing.
+
+## When in-place is acceptable
+
+A locally-scoped object that never escapes the function — a builder/accumulator you allocated and
+return once — is fine to mutate. The rule protects values that are *shared*: arguments, fields on
+long-lived state, anything another holder still references.