@ngockhoale/ukit 2.7.13 → 2.8.0

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

@@ -0,0 +1,18 @@
+---
+name: principle-fix-root-causes
+description: Reproduce first; fix the mechanism, not the symptom. No nil-guards that silence crashes. Apply to every bug fix.
+disable-model-invocation: true
+---
+
+# Fix Root Causes
+
+**Why:** A guard that silences a crash hides the bug and moves the failure somewhere harder to find. Fixing the mechanism kills the whole class; fixing the symptom rents it.
+
+- Reproduce the failure before touching code — no repro, no fix.
+- Trace back to the original trigger, not the nearest crash site.
+- Never add a nil-check, try/catch, or default that masks the mechanism.
+- The smallest fix that kills the mechanism ships; belt-and-suspenders does not.
+
+**Canonical workflow:** `root-cause-tracing` / `systematic-debugging` — this leaf is the trigger; those skills are the procedure.
+
+**Test:** Removing the fix makes the original reproduction fail again — the fix addresses the cause, not a coincidence.

package/templates/.claude/skills/principle-foundational-thinking/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: principle-foundational-thinking
+description: Pick core types and data structures before writing logic. Apply at the start of any non-trivial implementation or refactor.
+disable-model-invocation: true
+---
+
+# Foundational Thinking
+
+**Why:** Logic written before the data shape is chosen gets rewritten when the shape arrives. The structure is the program; the code is just its traversal.
+
+- Name the data shape and its organizing structure before writing any logic.
+- Choose types that make invalid states unrepresentable where the host language allows.
+- Derive functions from the shape — if a function fights the structure, the structure is wrong.
+- State the done condition as a checkable predicate before implementing.
+- Reuse the established analog's shape unless you can name why it does not fit.
+
+**Test:** Before the first function is written, you can say in one sentence what the core data looks like.

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

@@ -0,0 +1,16 @@
+---
+name: principle-guard-the-context-window
+description: Push bulk work to subagents; keep summaries in the main thread. Apply when facing large reads, noisy logs, or multi-file exploration.
+disable-model-invocation: true
+---
+
+# Guard the Context Window
+
+**Why:** The main thread's context is the budget every decision draws from. Bulk reads and noisy output spent there are unavailable for reasoning — delegate the bulk, keep the summary.
+
+- Send bulk exploration, wide searches, and noisy logs to subagents; receive only conclusions.
+- Read sections, not whole files; search before opening.
+- Keep the main thread for decisions, not data hauling.
+- A subagent's job is to return compressed context, not a transcript.
+
+**Test:** The main thread holds conclusions and file:line references, not raw dumps.

package/templates/.claude/skills/principle-laziness-protocol/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: principle-laziness-protocol
+description: Bias toward deletion and the smallest change that solves the problem. Apply when refactoring, evaluating diff size, or tempted to add abstractions.
+disable-model-invocation: true
+---
+
+# Laziness Protocol
+
+**Why:** Every line added is a line that must be read, tested, and maintained forever. The cheapest correct change is the one that adds the least code — and the best change often removes code instead.
+
+- Solve the stated problem with the smallest diff that satisfies it.
+- Prefer deleting dead weight over adding a parallel structure.
+- Refuse abstractions with one caller, options nobody asked for, and "might need it" hooks.
+- When two fixes are possible, pick the one that shrinks the codebase.
+- Scope creep is still creep when you wrote it yourself — do the task, not the adjacent task.
+
+**Test:** If the diff is larger than the problem statement justifies, cut until it isn't.

package/templates/.claude/skills/principle-migrate-callers-then-delete-legacy-apis/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: principle-migrate-callers-then-delete-legacy-apis
+description: Migrate every caller, then delete the old API in the same wave. Apply when renaming, replacing, or removing any shared interface.
+disable-model-invocation: true
+---
+
+# Migrate Callers, Then Delete
+
+**Why:** A new API beside the old one is two conventions, and the codebase keeps both forever. Clean cutover is the only cutover that finishes.
+
+- Migrate every caller to the new interface before the change is considered done.
+- Delete the old API, its shims, aliases, and re-exports in the same wave — not "later."
+- No compatibility layers unless the user explicitly asked for a deprecation window.
+- Search for callers by symbol and by string; dynamic references hide from both.
+
+**Test:** After the change, the old name returns zero hits in a repo-wide search.

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

@@ -0,0 +1,17 @@
+---
+name: principle-minimize-reader-load
+description: Collapse one-caller wrappers and shrink mutable scope. Apply when structuring functions, naming, or scoping state.
+disable-model-invocation: true
+---
+
+# Minimize Reader Load
+
+**Why:** The reader's working memory is the scarcest resource in the codebase. Every indirection, wrapper, and wide mutable scope spends it on plumbing instead of meaning.
+
+- Collapse wrappers that have exactly one caller and add no contract.
+- Shrink mutable scope: const by default, narrowest lifetime, fewest places a value can change.
+- Name things after what they are for, not how they are built.
+- Keep related decisions adjacent; a reader should not jump three files to see one choice.
+- Prefer boring, linear flow over clever control flow.
+
+**Test:** A reader can explain what the code does after one pass, without opening callees.

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

@@ -0,0 +1,16 @@
+---
+name: principle-model-the-domain
+description: Encode domain rules in structure rather than scattered conditionals. Apply when the same business rule appears in more than one place.
+disable-model-invocation: true
+---
+
+# Model the Domain
+
+**Why:** A rule expressed as scattered if-checks drifts: each copy is updated on a different schedule and they diverge silently. Structure cannot diverge — it is checked once, everywhere.
+
+- Encode domain invariants in types, enums, and data structures, not in repeated conditionals.
+- When the same predicate appears twice, the domain is asking for a named concept — create it.
+- Push rules to the edges: validate once at the boundary, then trust the structure inside.
+- Name domain concepts with domain vocabulary, not implementation vocabulary.
+
+**Test:** Changing a domain rule touches one definition, not a grep across the codebase.

package/templates/.claude/skills/principle-never-block-on-the-human/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: principle-never-block-on-the-human
+description: Proceed, report, course-correct after. Apply whenever tempted to stop and ask instead of acting.
+disable-model-invocation: true
+---
+
+# Never Block on the Human
+
+**Why:** A stopped agent produces nothing; a proceeding agent produces something correctable. Most questions answer themselves with tools, repo context, or a cheap experiment.
+
+- Ask only for: irreversible writes, a genuine preference call no experiment settles, or a real dead end.
+- Everything else: do it, report it, course-correct on feedback.
+- "I wasn't sure" is not a blocker — pick the informed default and state the assumption.
+- A question you can answer with a tool call is a tool call, not a question.
+
+**Test:** The turn ends with work done and assumptions stated, not with an unanswered question that tools could have resolved.

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

@@ -0,0 +1,18 @@
+---
+name: principle-prove-it-works
+description: Verify the real artifact, not a proxy, self-report, or "it compiles". Apply before claiming any work is done.
+disable-model-invocation: true
+---
+
+# Prove It Works
+
+**Why:** "It compiles" proves the syntax parses; self-report proves nothing. Only the real artifact exercised on the real surface demonstrates the change works.
+
+- Run the actual thing: the command, the page, the endpoint — not a stand-in.
+- For a bug fix, the original reproduction must now pass on the same surface.
+- "Inconclusive" and wrong-surface verification are not passes.
+- Evidence is observed output, not reasoning about output.
+
+**Canonical workflow:** `verification-before-completion` — this leaf is the trigger; that skill is the procedure. Read it before claiming completion.
+
+**Test:** The final report pastes the command and its real output, not a summary of what should have happened.

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

@@ -0,0 +1,16 @@
+---
+name: principle-sequence-verifiable-units
+description: Break work into small units, each ending in a verifiable state. Apply when planning multi-step changes.
+disable-model-invocation: true
+---
+
+# Sequence Verifiable Units
+
+**Why:** A large unverified change fails as a whole and localizes nothing. Small units that each end green isolate failure to the last step and keep the work resumable.
+
+- Order work so every unit ends in a state you can check.
+- Verify each unit before starting the next — errors compound silently otherwise.
+- Keep each unit independently revertable.
+- The unit boundary is where evidence is collected, not where the todo item happens to end.
+
+**Test:** At any point in the sequence, the last completed unit has concrete evidence it works.

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

@@ -0,0 +1,16 @@
+---
+name: principle-subtract-before-you-add
+description: Remove dead weight before building on top of it. Apply before adding features, files, or abstractions to an existing area.
+disable-model-invocation: true
+---
+
+# Subtract Before You Add
+
+**Why:** New code built on top of dead code inherits its confusion and doubles the surface the next reader must map. Removal first makes the addition smaller and the review easier.
+
+- Before adding, list what in the touched area is already dead, duplicated, or bypassed.
+- Delete obsolete code, comments, aliases, and re-exports in the same wave as the change that obsoletes them.
+- Never keep a deprecated path "just in case" — version control is the backup.
+- If the addition replaces something, the something leaves in this diff, not a later one.
+
+**Test:** The diff's deletion count is non-trivial whenever the change replaces an existing path.

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

@@ -0,0 +1,18 @@
+---
+name: principle-test-behavior-not-implementation
+description: Assert what consumers observe, not how the code is wired. Apply when writing or changing any test.
+disable-model-invocation: true
+---
+
+# Test Behavior, Not Implementation
+
+**Why:** Tests that assert internals break on every refactor and pass on every real bug. A test earns its place only if a plausible bug would fail it.
+
+- Assert observable contract: output, state, errors — never wiring, field copies, or mock echoes.
+- A test that passes when every imported function returns undefined is testing nothing.
+- Never add test-only methods to production code to make a test easier.
+- Delete tests that pin wording, defaults, or implementation details — do not re-pin them.
+
+**Canonical workflow:** `testing-anti-patterns` — this leaf is the trigger; that skill is the procedure.
+
+**Test:** If the test would still pass when every imported function returns `undefined`, rewrite the assertion or delete the test.