Claude-Tools-for-Delphi

Triage a Delphi FMX Android bug/crash from the PC over adb: capture logcat, pull the app's LightCore.ExceptionLogger log via run-as, classify the failure (SIGUSR1 IDE noise / Pascal exception / Java exception / native tombstone / deployment), symbolicate stripped-.so addresses against the linker .map (Tools\MapLookup.ps1), then root-cause and fix (build via light-compiler, never release). Use when the user says "/light-bug-Android", "the Android app crashes", "the app silently disappears on the phone", "triage this logcat", "exception class 10", or an FMX bug shows only on Android.

Diagnose and fix a Delphi bug end-to-end, however it arrived: a Thunderbird crash report (.mad), a pasted exception/stack trace, or a symptom described in plain words. Routes internally — a .mad or 'crash report' goes to the light-bug-MadShi pipeline, an Android-only symptom hands off to /light-bug-Android, everything else runs here: intake, reproduce (a failing DUnitX test preferred), localize, a MANDATORY derailment check before any fix, fix, then verify and compile (never releases). Use whenever the user reports a bug, crash, or unexpected behavior in a Delphi project — says "/light-bug", "/light-bug bionix", "I have a crash in program X", "the app does Y instead of Z", "this doesn't work", pastes an exception or stack trace, forwards a bug-report email, or describes an app crashing/hanging/misbehaving — even without typing a command.

Fix Delphi vocabulary and writing-clarity issues in Markdown docs — non-Delphi term swaps + bounded clarity rewrites. Say "check vocab", "fix vocabulary", "delphi terms", "clean up the md", or after writing/editing *.md in a Delphi project.

Audit Claude Code config files (settings.json, settings.local.json, .mcp.json) across the computer for unsafe or malicious content — hooks that run shell commands, credential/proxy env vars, arbitrary MCP servers, permission-bypass modes, over-broad allow rules. Classifies each finding DANGEROUS / SUSPICIOUS / SAFE. Read-only. Use when the user invokes `/light-security-ClaudeSettingsAudit`, says "check my settings.local.json for malware", "are my Claude permission files safe", "scan my Claude config", or "audit settings.json across the computer".

Summarize a YouTube transcript .txt file — cleans it first, then produces a structured summary (with a Delphi 13 / LightSaber adaptation section when the talk is about programming). Launches the light-web-YoutubeSummarizer agent. Use when the user invokes `/light-web-YoutubeSummarizer`, says "summarize this transcript", "what can I learn from this video for my Delphi work", or points at a file in c:\AI\Claude Code\Transcript\.

Pause mid-task and verify your own conclusions before continuing: classify every load-bearing conclusion VERIFIED / INFERRED / ASSUMED with evidence, actively attack the unverified ones, and find the earliest wrong turn if one exists. Not Delphi-specific — usable in any long or drifting task, in any language. Use when the user says "derailment check", "are you on track", "checkpoint yourself", "pause and check your conclusions", "/light-task-DerailmentCheck", or after any long autonomous stretch. ALSO fire this on yourself, unprompted, whenever: the user says "nope"/"no"/"wrong"/"stop" or otherwise corrects you; a fix didn't change the symptom; two fix attempts on the same problem both failed; you're editing a file your own analysis never mentioned; you're explaining away contradicting evidence instead of checking it; or you're about to act without ever having reproduced the problem.

Audit Delphi source for Win64 truncation bugs — pointer-width API results (DWORD_PTR/LRESULT/handles) stored in 32-bit variables (Integer/Cardinal/DWORD/UInt), and 32-bit casts of pointers passed to the API. Say "audit for Win64 bugs", "check 64-bit safety", "search for SysIL-class bugs".

Alias for /light-bug-MadShi with the BioniX product preselected. Diagnose and fix a BioniX Wallpaper crash report from Thunderbird, then build (never release). Use when the user says "/light-bug-BioniX", "new BioniX bug report", "check the latest BioniX crash", or similar.

Diagnose and fix a Delphi crash report (madExcept .mad) for any registered product (BioniX, ...). Reads the product profile in products.ini, lists the recent .mad attachments across that product's Thunderbird mbox(es), lets the user pick one (or accept the newest), then launches the light-bug-MadShi agent to diagnose, fix, and build (never release). This is the crash-report-specific pipeline behind the general /light-bug skill's Step 0 routing — invoke it directly when you already have a .mad file or Thunderbird crash report in hand. Use when the user says "/light-bug-MadShi", "/light-bug-MadShi bionix", "new crash report", "check the latest .mad", or similar.

Audit a Delphi project's own classes (INCLUDING forms) for bad shapes — god classes, anemic data classes, misplaced responsibility, fat config records, shared mutable singletons, Ex-downcast holders. Reports ranked reshapes (extract-class, move-method, replace-singleton); never refactors. Say "is this a god class", "review the class design", "find anemic classes". For UNIT merges use light-code-ArchitectureUnit.

Audit a Delphi project's own units (files) for SHALLOW modules that should merge into one deep module — information leakage, temporal decomposition, pass-through layers, always-paired usage. Reports ranked merge candidates; never merges. Say "find shallow units", "what units should be merged". For CLASS shapes use light-code-ArchitectureClass.

Turn "I want feature X" into a designed, sliced, test-driven Delphi implementation — align, PRD, vertical slices, red-green each (failing DUnitX test first), then hand to light-review-PostEdit / light-review-Full. Say "add a feature", "build feature X", "implement a new feature", "create a new screen/dialog/option".

Reference for Delphi memory-safety and exception handling — the try..finally gold standard, freeing owned fields, FreeAndNil, Owner-managed components, functions that return objects, specific try..except, domain exception hierarchies and bare raise. Load this when writing or reviewing code that creates objects, manages lifetimes, or handles exceptions.

Audit Delphi FMX source for cross-platform issues — Windows-only APIs, hardcoded paths, missing platform conditionals, mobile-incompatible patterns. Say "check this for Android/iOS", "is this safe on mobile/macOS/Linux", "audit for cross-platform issues".

Scan imported/3rd-party Delphi code for style compliance, common mistakes, dangerous patterns (leaks, unsafe casts, missing try/finally). Not for our own code — use /light-review-Full. Say "check this 3rd-party unit", "scan the imported library".

Scan project markdown docs (CLAUDE.md, README.md, docs/*.md) for drift after code changes. Flag sections out of sync with current code — class names, file paths, settings keys, procedure signatures, architecture claims. Propose and apply concrete edits. Use when user says "update md", "check docs", "refresh claude.md", "verify docs", or invokes /light-md-DriftUpdate.

Prune and tighten a CLAUDE.md or other agent/skill instruction markdown — cut bloat/duplication, fix stale rules, relayer misplaced content, without losing load-bearing info. Backs up first. Say "clean up this CLAUDE.md", "my CLAUDE.md is too long".

One-question-at-a-time design interview before any non-trivial Delphi task — each question carries your recommended answer, highest-stakes first, skip what you can decide yourself. Say "align first", "interview me", or "ask before you build".

Quick index of the GoF design patterns that actually pay off in Delphi desktop/mobile code, each with its Delphi-native shortcut (anonymous methods, virtual methods, System.Messaging, class functions, enumerators) so you reach for the full pattern only when it earns its keep. Load this when choosing a structure for varying behaviour, decoupling producer from consumer, building objects step by step, or wrapping/adapting a subsystem. Adapted to Gabriel's stack: composition and concrete types first, interfaces only where they genuinely pay, no over-engineering.

Reference catalog of behaviour-preserving Delphi refactorings — Extract Method, Extract Class, Guard Clauses, Named Constants, Replace Conditional with Polymorphism, Introduce Parameter Object (record), Remove with, Rename, Inline Method, and introducing a test seam via a shared base class. Load this when cleaning up smelly code, taming a long method or god class, or planning a safe refactor. Adapted to Gabriel's stack: shared base / concrete typing over interfaces, test-green before and after, compile only via the light-compiler agent. Pairs with /light-code-ArchitectureUnit and /light-code-ArchitectureClass.

Reference for writing or reviewing Delphi threading code on VCL and FMX (incl. Android/iOS) — TThread, TThread.CreateAnonymousThread, PPL (TTask/TParallel/TFuture), Synchronize vs Queue, TInterlocked/TCriticalSection/TMonitor/TLightweightMREW, TThreadList/TThreadedQueue/TEvent, graceful cancellation and thread-safety. Load this when a task works with threads, or touches shared state from more than one thread — or when reviewing such code. FMX/mobile-aware. Composition over interfaces.

Counter-analyze review findings already in this conversation, verify each surviving claim against the code and docs, drop false positives, then fix ALL that remain — not just the easy ones. Use after a review/audit/listing produced findings; say "counter-analyze these findings", "vet and fix", or "verify then fix all of these".

Reference for structuring Delphi DUnitX unit tests — test project layout, [TestFixture]/[Setup]/[TearDown]/[Test], Method_Scenario_Expected naming, the assertion cheat-sheet, substituting collaborators with a concrete fake (shared base, no interface required), and SQLite :memory: integration tests. Load this when writing, organising or reviewing DUnitX tests. Adapted to Gabriel's rules — no fake/zero-assert tests, no form/UI tests, compile ONLY via the light-compiler agent, then launch the EXE yourself. Pairs with /light-review-RedGreen and /light-review-FakeTest.

Audit a Delphi DUnitX/DUnit suite for FAKE or WEAK tests that pass without verifying the behavior they name (zero assertions, Assert.Pass-only, tautologies, setup-only). Establishes the green baseline, launches the auditor agent, and can PROVE fakeness with a git-safe mutation pass. Say "are these tests fake", "audit test integrity", "did we game the tests to pass".

Full three-stage Delphi code review pipeline: find correctness bugs, counter-analyze + apply surviving fixes, verify + compile. Say "review this Delphi code", "code review FormFoo.pas", "deep review the Lib folder".

Verify the code you just wrote (fix or feature) works — confirm each change matches intent, broke nothing observable, missed no call sites, didn't break DFM/FMX bindings; revert what fails; then test or compile. Use after implementing a fix/feature or /light-review-PostEdit.

Red-green TDD for any Delphi change (new behavior OR bug fix): write the FAILING DUnitX test first, confirm red on its assertion (not a compile error), then drive to green, compiling only via the light-compiler agent. For a bug the failing test is the reproduction. Say "TDD this", "write the test first", "reproduce the bug with a test", "red-green".

Review HTML, CSS, or JavaScript for errors, formatting, best practices, accessibility, cross-browser issues. Say "review this HTML/CSS/JS", "check my stylesheet", or after writing/editing web frontend code.