LUC4N3X

thalarch-kotlin-jpa

Kotlin-specific JPA/Hibernate persistence engineering for entities, repositories, relationships, fetch plans, transactions, equality/identity, uniqueness constraints, optimistic locking, and N+1 or LazyInitialization diagnostics.

thalarch-kotlin-migration

Semantics-preserving Java→Kotlin and Kotlin/tooling migration workflow for staged conversions where behavior, interop, nullability, framework semantics, serialization, persistence, and public API compatibility must not drift.

thalarch-context

Curates task context to reduce hallucination, stale assumptions, and attention dilution. Use when starting unfamiliar work, switching major task areas, after long sessions/compaction, when agent quality drifts, or when a task would otherwise require loading many files/logs/docs. Builds a compact evidence packet from rules, relevant source, tests, interfaces, current failures, and selectively revalidated project/general memory instead of flooding the model with unrelated context.

API & Backend Listed

thalarch-api

Contract-first API engineering for HTTP/REST, RPC, event-driven interfaces, and service boundaries. Use for new endpoints, API changes, client/server integrations, pagination, idempotency, errors, retries, compatibility, or externally consumed contracts.

thalarch-architecture

Evidence-driven software architecture design and review. Use for module/service boundaries, dependency direction, monolith vs distributed decomposition, system design, scalability, platform/data decisions, ADRs, architecture refactors, or cross-cutting changes where tradeoffs and quality attributes matter more than local code style.

thalarch-autoresearch

Runs bounded evidence-driven experiment loops for measurable optimization, repeated hypothesis testing, agent/prompt tuning, benchmark improvement, difficult debugging with a stable evaluator, and implementation search. Establishes a reproducible baseline, changes one causal surface at a time, measures under comparable conditions, keeps only demonstrated improvements, reverts failed candidates, records an experiment ledger, protects correctness guardrails, and stops on budget or convergence. Never self-modifies durable rules, merges, releases, force-pushes, or broadens scope merely to improve a score.

thalarch-browser-qa

Verifies web UI behavior in a real browser using the strongest browser/DevTools/Playwright capability actually available on the current host. Use after frontend changes or for browser-only bugs. Checks interaction, console, network, responsive behavior, screenshots, recordings, accessibility signals, and performance evidence rather than treating a successful build as proof.

thalarch-code-craft

Universal coding-quality overlay for implementation and review across languages. Use on meaningful code changes to keep the solution idiomatic, minimal, repository-native, incrementally verifiable, and evidence-backed while preventing common agent mistakes such as invented APIs, speculative abstractions, broad exception swallowing, dependency bloat, and fake-success behavior.

thalarch-codebase-intel

Builds a bounded, evidence-backed mental model of an unfamiliar or large repository before architecture work, broad refactors, feature-level repair, onboarding, review, or cross-module debugging. Uses read-only project and diff probes to orient routing without replacing task-relevant source inspection.

API & Backend Listed

thalarch-data-sql

Database and SQL engineering for relational persistence, migrations, transactions, query correctness, indexing, pagination, ORM behavior, and data-safe rollout. Use when code touches schemas, queries, transactions, repositories/ORMs, migrations, or database performance.

thalarch-design-system

Creates or extracts a semantic visual system for websites and applications. Use before major frontend redesigns, multi-page sites, brand-heavy UI, or when an existing codebase needs its visual language made explicit. Produces a compact design contract covering atmosphere, color roles, typography, spacing, components, layout, motion, responsive behavior, imagery, and anti-patterns without forcing a particular framework or design tool.

thalarch-doubt

Fresh-context adversarial challenge for non-trivial engineering decisions before they harden into implementation. Use for D2+ work when a decision changes branching, crosses boundaries, asserts a non-compiler-verifiable property, has high blast radius, or rests on uncertain context. Extracts the artifact and contract, challenges them independently, reconciles findings against evidence, and stops after a bounded number of cycles instead of turning review into recursion.

thalarch-epistemic-guard

Anti-hallucination evidence gate for repository, API, runtime, external-fact, visual, and completion claims. Use on all meaningful Thalarch work and especially when exact files, symbols, commands, versions, APIs, logs, test results, commit metadata, current documentation, or runtime behavior matter. Requires inspect-before-claim, source hierarchy, claim-to-evidence matching, semantic validation, and explicit UNKNOWN/UNVERIFIED states instead of plausible invention.

thalarch-go

Project-aware Go engineering for services, CLIs, libraries, concurrency, networking, and systems code. Use for Go source, modules, goroutines/channels, APIs, tests, profiling, performance, or Go-specific refactoring.

thalarch-image-to-code

Visual-fidelity workflow for translating screenshots, generated design references, mockups, or section comps into real frontend code. Use when matching a visual reference is central to acceptance. Extracts a measurable design contract before implementation and verifies the real browser result rather than treating the reference image or source code as proof.

thalarch-image

Routes and governs image-centric work across generation, editing, inspection, comparison, annotation, screenshots, branding, raster assets, vector assets, diagrams, infographics, mockups, and export validation. Use whenever an image is an input, output, reference, acceptance artifact, or major source of truth. Chooses the correct host-supported visual workflow before generation or editing begins.

thalarch-imagegen

Creates and edits project images through the strongest image-generation/editing capability actually available on the current host. Uses disciplined visual briefs, reference-role labeling, light art-direction guidance, invariants, deliberate iteration, exact-text handling, brand consistency, design-reference grounding, and post-generation review. Use for raster artwork, photography, mockups, marketing assets, textures, concept visuals, compositing, and semantic image edits.

thalarch-java

Project-version-aware Java/JVM engineering for production code, libraries, services, and enterprise applications. Use for Java source, Maven/Gradle JVM projects, Spring when actually present, concurrency, JVM performance, testing, persistence, or Java-specific refactoring.

thalarch-jvm-concurrency

Java/JVM concurrency and asynchronous-execution specialist. Use when code touches threads, executors, virtual threads, CompletableFuture, locks, atomics, shared mutable state, ThreadLocal or ScopedValue, Spring @Async, blocking work, cancellation, or thread-safety/performance risks. Requires version-aware API verification and evidence for race/deadlock/performance claims.

thalarch-kotlin

Project-aware Kotlin engineering for JVM, Android, server, and multiplatform code. Use for Kotlin source, coroutines/Flow, Gradle Kotlin projects, Compose when present, KMP boundaries, testing, performance, interoperability, and Kotlin-specific refactoring.

thalarch-mode

High-rigor model-agnostic engineering and visual-production skill protocol for complex, risky, multi-file, debugging, architecture, refactoring, performance, API/data, Java, Kotlin, Python, TypeScript, Go, Rust, UI, images, Android, CI, security, observability, or publication tasks. Routes work through the smallest relevant skill stack, context hygiene, adaptive deliberation, source grounding, anti-hallucination evidence gates, in-flight doubt, host-native specialists when available, causal analysis, risk-sized review, and cold verification before completion. Use for Thalarch/deep-work/maximum-quality requests or whenever regression/uncertainty risk is meaningful. Skip ceremony for trivial edits.

thalarch-observability

Production observability and instrumentation skill for services, background jobs, queues, external integrations, retries, distributed systems, and production incident follow-up. Use when adding or reviewing logs, metrics, traces, correlation, alerting, telemetry privacy, or when a feature needs evidence that production behavior can be diagnosed after release.

thalarch-performance

Evidence-driven performance engineering for latency, throughput, CPU, memory, startup, build time, rendering, I/O, concurrency, and scalability problems. Use for explicit optimization work or when profiling/benchmark/build evidence is needed before changing a hot path or feedback loop.

thalarch-python

Project-version-aware Python engineering for services, libraries, automation, data tooling, and applications. Use for Python source, async code, typing, packaging, APIs, testing, profiling, data pipelines, or Python-specific refactoring.

thalarch-reasoning

Adaptive deliberation layer for difficult engineering and design work. Use when a task is ambiguous, high-risk, multi-step, architecture-heavy, debugging-heavy, version-sensitive, cross-module, or otherwise likely to reward slower reasoning. Forces explicit problem framing, competing hypotheses/approaches, disconfirmation, independent challenge, evidence-based adjudication, uncertainty tracking, and a final falsifiable proof without exposing private chain-of-thought or adding ceremony to trivial work.

thalarch-refactor

Behavior-preserving refactoring protocol for simplifying, restructuring, modularizing, or modernizing existing code without silently changing externally observable behavior. Use for non-trivial cleanup, decomposition, abstraction changes, package/module moves, or legacy modernization where regression risk matters.

thalarch-review

Runs risk-sized, evidence-first review of code changes. Use before completion, PR creation, or after meaningful implementation. Separates requirement compliance from engineering quality, uses independent reviewer contexts and perspective shifts to break self-review blind spots, confirms findings before fixing them, and supports lite, standard, and deep review depth.

thalarch-rust

Project-aware Rust engineering for libraries, services, CLIs, async applications, and systems code. Use for Rust source, Cargo workspaces/features, ownership/lifetimes, unsafe code, concurrency, tests, performance, or Rust-specific refactoring.

thalarch-skill-intelligence

Autonomous skill-selection layer for Thalarch. Use at the start of non-trivial work and again after project discovery when the current host may expose stronger project-local, official platform, Thalarch, or third-party expertise. Shortlists the smallest high-value skill stack based on task fit, project/toolchain compatibility, authority/currentness, tool leverage, evidence needs, redundancy, conflicts, context cost, and actual host availability.

thalarch-source-grounding

Grounds version-sensitive framework, library, runtime, browser, database, and platform decisions in the exact project version plus current primary documentation. Use before implementing or reviewing non-trivial external APIs, configuration, migration guidance, compatibility behavior, or framework-specific patterns where model memory can be stale.

thalarch-test

Designs high-value regression, property, integration, fuzz, and risk-based mutation tests for behavior changes. Use after a root cause is known or a feature contract exists. Focuses on tests that can actually falsify the implementation, negative/error paths, red-green proof, boundary matrices, and avoiding mock-heavy tests that merely restate implementation details.

thalarch-typescript

Project-aware TypeScript/JavaScript engineering for browser, Node.js, full-stack, libraries, and tooling. Use for TS/JS source, framework code, async behavior, typing, package/toolchain work, testing, performance, or TypeScript-specific refactoring.

thalarch-visual-qa

Performs evidence-first visual QA for images, generated assets, screenshots, branding, image edits, diagrams, and implemented web/mobile UI. Use after any visual deliverable or when comparing a result with a reference/baseline. Verifies pixels and metadata rather than trusting prompts, source code, or creator reports, with a light aesthetic polish check for professional visual work.

thalarch-web-design

Designs and implements distinctive, production-grade websites, landing pages, dashboards, web apps, and frontend components. Use when the user asks to build, redesign, beautify, or substantially restyle a web interface. Infers the brief before styling, establishes a product-specific aesthetic direction/design system, uses image-to-code when visual references are central, and requires responsive browser evidence instead of generic AI-template output.

thalarch-supply-chain

Audits provenance and instruction-supply-chain risk for external skills, MCP/tool descriptions, retrieved prompts, agent packs, plugins, installers, and imported automation. Use before trusting third-party agent instructions or when prompt/tool poisoning, hidden directives, integrity drift, or credential exfiltration is plausible.

thalarch-router

Chooses the smallest compatible process, language, domain, platform, visual, cognitive, and installed-skill stack for a task. Use before complex work and after project discovery. Combines autonomous skill intelligence with task, stack, risk, evidence, source-grounding, context, no-regression, memory/experience, teacher/eval, and in-flight doubt routing instead of requiring the user to manually name the best skills.

thalarch-android

Coordinates Android/Kotlin/Jetpack Compose/Gradle/Media3 work. Use for Android UI, playback, services, device behavior, build/toolchain, R8, Room/data access, testing, edge-to-edge, adaptive layout, localization, performance, or runtime debugging. Prefer official Google Android skills/CLI when installed and use device or emulator evidence for runtime-specific acceptance.

thalarch-compound

Extracts reusable, verified engineering knowledge after difficult tasks so future work gets cheaper. Use after a non-trivial bug fix, architecture discovery, recurring failure, benchmark, or review that revealed a stable lesson. Routes useful outcomes through thalarch-experience, thalarch-memory, and optionally thalarch-project-brain while rejecting guesses, sensitive data, task-specific noise, and overbroad generalization.

thalarch-compose-ui

Product-quality Jetpack Compose UI workflow for redesigning or extending an existing Android app without losing its design language, accessibility, adaptive behavior, localization, state correctness, or runtime performance. Use for Compose screens, settings, media/player UI, visual redesigns, or interaction-heavy Android surfaces that require rendered device evidence.

thalarch-entity-matching

Designs safe automatic entity-resolution and candidate-matching logic for searches such as title+artist to media ID, product to catalog item, album to provider entity, or similar fuzzy identity mapping. Use when a system must choose among near-duplicate remote search results without silently binding the wrong entity.

thalarch-experience

Converts verified task outcomes into compact reusable experience cards. Use after meaningful bug fixes, failed hypotheses, performance investigations, migrations, design corrections, or repeated workflows when the result contains a lesson worth reusing. Captures trigger, discriminator, intervention, failed alternatives, evidence, transfer conditions, and counterexamples; separates project lessons from general engineering knowledge; and prevents one successful anecdote from becoming an overbroad rule.

thalarch-localization

Localization and i18n quality workflow for multi-locale applications. Use when adding or changing user-facing strings, locale resources, plurals, formatting, RTL behavior, or when a UI redesign must remain complete and natural across all languages supported by the project.

thalarch-media3

Specialist reliability workflow for AndroidX Media3 playback, MediaSession/MediaLibrarySession, MediaLibraryService, Android Auto browsing, queue/timeline identity, caching, preload/recovery, audio/video track selection, and audio-processing pipelines. Use when Media3 behavior, APIs, deprecations, playback lifecycle, controller contracts, or automotive media browsing are material.

thalarch-memory

Retrieves, classifies, validates, and optionally persists compact durable knowledge so future tasks can reuse verified experience without treating memory as current truth. Use when prior project decisions, recurring failures, user-authorized workflow preferences, or general engineering lessons could materially improve a task. Separates IGNORE/SESSION/PROJECT/GENERAL memory, revalidates load-bearing memories against current evidence, prevents sensitive-data and chain-of-thought persistence, and prefers small retrieval capsules over context dumps.

thalarch-no-regression

Defines a compact preservation contract before risky changes to working systems. Use for cache, playback, persistence, sync, migrations, concurrency, networking, UI state machines, or any task where a narrow improvement could accidentally break adjacent behavior that currently works.

thalarch-project-brain

Maintains an opt-in, repository-local project knowledge layer for stable architecture, invariants, decisions, regressions, commands, design rules, and project-scoped experience. Use when a project is revisited repeatedly and durable context would reduce rediscovery. Current repository/runtime evidence always outranks the brain; entries carry provenance/freshness; stale facts are retired; secrets and private chain-of-thought are forbidden; and repository files are created or changed only when durable project memory is explicitly authorized.

thalarch-teacher

Runs a bounded teacher/judge/revision loop around model-produced engineering work. Use when an independent evaluator can materially improve correctness, scope discipline, regression safety, evidence honesty, design quality, or general-purpose skill/prompt behavior. Judges artifacts and acceptance evidence rather than private reasoning, uses hard gates before optional scoring, prevents self-certification and benchmark gaming, limits revision cycles, and combines with thalarch-autoresearch plus frozen/holdout evaluations before promoting durable generic changes.

thalarch-ci

Diagnoses and reviews CI/CD, GitHub Actions, build pipelines, packaging, signing, and release automation. Use for failing checks or workflow changes. Separates log evidence from guesses, reviews untrusted input and token permissions, and never deploys/releases merely to test a fix unless explicitly authorized.

thalarch-debug

Performs causal root-cause debugging before fixes. Use for bugs, crashes, failing tests or builds, intermittent behavior, regressions, incorrect state, networking failures, or performance anomalies. Requires reproduction/evidence, a falsifiable hypothesis, minimal diagnostic experiments, and architecture reassessment after repeated failed hypotheses.

thalarch-dependency

Safe dependency and toolchain upgrade workflow. Use when adding, replacing, or upgrading libraries, language runtimes, plugins, build tools, frameworks, lockfiles, or transitive dependency constraints. Minimizes unrelated churn and verifies version-specific APIs.

thalarch-evals

Evaluates and retunes Thalarch itself. Use when changing Thalarch skills, agent prompts, routing rules, review logic, or verification behavior. Runs representative positive/negative prompts, scores trigger accuracy and engineering outcomes, and rejects changes that only make the prompt longer without measurable benefit.

thalarch-git

Safe Git and GitHub delivery workflow for any repository. Use when the user asks to branch, commit, push, prepare/open a pull request, update an existing PR, or otherwise publish code changes. Preserves unrelated work, verifies the exact diff, keeps commits intentional, and never merges/releases/force-pushes unless explicitly authorized.

thalarch-security

Performs evidence-backed application and agentic-workflow security review. Use for auth, authorization, untrusted input, secrets, cryptography, network exposure, command execution, file/path handling, dependencies, GitHub Actions, MCP/tool integrations, or any explicit security audit. Trace sources to sinks and confirm findings to reduce false positives.

thalarch-spec

Turns broad feature or architecture requests into an executable acceptance contract. Use for multi-file features, refactors, migrations, architecture work, ambiguous behavior, or whenever implementation could succeed technically while missing the user's actual intent.

thalarch-ui

Directs distinctive, product-specific UI/UX work and visual verification. Use for redesigns, new interfaces, layout, styling, motion, interaction, responsive behavior, accessibility, or when the user asks to make an interface more polished/professional. Avoids generic AI UI and requires rendered evidence when appearance is part of acceptance.