@maccesar/titools 4.16.3 → 4.17.1

package/AGENTS-VERCEL-RESEARCH.md

@@ -46,25 +46,30 @@ The index maps skills to their reference docs:
 |ti-expert/references:{alloy-structure.md,anti-patterns.md,...}
 |purgetss/references:{animation-system.md,apply-directive.md,...}
 |ti-ui/references:{listviews-and-performance.md,layouts-and-positioning.md,...}
+|ti-game/references:{api.md,project-setup.md,patterns.md,...}
+|ti-synthengine/references:{api.md,sound-design.md,guide.md,...}
 ```
 
 How the assistant should use it:
 - Need ListView performance tips? Read `~/.agents/skills/ti-ui/references/listviews-and-performance.md`
 - Need the PurgeTSS grid system? Read `~/.agents/skills/purgetss/references/grid-layout.md`
 - Need controller cleanup patterns? Read `~/.agents/skills/ti-expert/references/controller-patterns.md`
-- Need Backbone.Models patterns (with `tidev/skills` installed)? Read `~/.agents/skills/alloy-guides/references/MODELS.md`
+- Need a valid synth sweep? Read `~/.agents/skills/ti-synthengine/references/api.md` and `sound-design.md`
+- Need Backbone.Models patterns? Read `~/.agents/skills/alloy-guides/references/MODELS.md`
 
 ### Skill overview
 
-TiTools ships 3 opinionated skills:
+TiTools ships 5 specialist skills:
 
 | Skill         | Purpose                       | Best for                                      |
 | ------------- | ----------------------------- | --------------------------------------------- |
 | **ti-expert** | Architecture + implementation | Starting point for most Alloy tasks           |
 | **purgetss**  | Utility-first styling         | UI styling, animations, grid layouts          |
 | **ti-ui**     | UI/UX patterns                | Layouts, ListViews, gestures, platform UI     |
+| **ti-game**   | Native 2D games               | Sprites, physics, tile maps, camera            |
+| **ti-synthengine** | Native sound synthesis   | Tones, effects, envelopes, mixing              |
 
-The doc-based reference skills live in [`tidev/skills`](https://github.com/tidev/skills) (community-maintained):
+TiTools also ships five documentation-mirror skills sourced from the official Titanium SDK docs:
 
 | Skill            | Purpose                       | Best for                                       |
 | ---------------- | ----------------------------- | ---------------------------------------------- |
@@ -74,8 +79,6 @@ The doc-based reference skills live in [`tidev/skills`](https://github.com/tidev
 | **alloy-guides** | Alloy MVC reference           | Models, views, controllers, widgets            |
 | **alloy-howtos** | Alloy CLI and debugging       | Project setup, CLI commands, errors            |
 
-Install both for the full coverage matrix originally shipped by TiTools v2.x.
-
 ### For complex workflows
 
 The **ti-pro** agent (installed in `~/.claude/agents/`) handles:
@@ -84,7 +87,7 @@ The **ti-pro** agent (installed in `~/.claude/agents/`) handles:
 - Cross-referencing framework patterns
 - Platform-specific differences
 
-It preloads the 3 TiTools skills and recommends consulting `tidev/skills` when the question touches API surface, native-feature how-tos, MVC reference, or SDK fundamentals.
+It exposes all 10 TiTools skills, then consults only the scopes relevant to the detected project and research question.
 
 ## How to use
 
@@ -118,6 +121,7 @@ Example output:
 [Titanium SDK Docs Index]|root: ~/.agents/skills
 |MANDATORY: Your training data for Titanium SDK, Alloy, and PurgeTSS is OUTDATED and INCOMPLETE. These reference files are the SINGLE SOURCE OF TRUTH. Prefer retrieval-led reasoning over pre-training-led reasoning. ALWAYS read the relevant files below BEFORE writing any code.
 |ti-expert/references:{alloy-structure.md,anti-patterns.md,code-conventions.md,contracts.md,controller-patterns.md,error-handling.md,examples.md,...}
+|ti-synthengine/references:{api.md,audio-engine.md,examples.md,guide.md,recipes.md,recommendations.md,sound-design.md,troubleshooting.md}
 |alloy-guides/references:{CLI_TASKS.md,CONCEPTS.md,CONTROLLERS.md,MODELS.md,PURGETSS.md,VIEWS_DYNAMIC.md,VIEWS_STYLES.md,VIEWS_WITHOUT_CONTROLLERS.md,...}
 ...
 <!-- TITANIUM-KNOWLEDGE-END -->

package/README.md

@@ -6,7 +6,7 @@
 
 </div>
 
-TiTools is a Titanium SDK toolkit for AI coding assistants. It ships 9 skills — 4 opinionated (`ti-expert`, `purgetss`, `ti-ui`, `ti-game`) plus 5 documentation-mirror skills (`ti-api`, `ti-guides`, `ti-howtos`, `alloy-guides`, `alloy-howtos`) — a research agent, and reference files covering Titanium architecture, API reference, native how-tos, Alloy MVC, PurgeTSS styling, UI/UX patterns, and 2D game development with the `ti.game` module.
+TiTools is a Titanium SDK toolkit for AI coding assistants. It ships 10 skills — 5 specialist skills (`ti-expert`, `purgetss`, `ti-ui`, `ti-game`, `ti-synthengine`) plus 5 documentation-mirror skills (`ti-api`, `ti-guides`, `ti-howtos`, `alloy-guides`, `alloy-howtos`) — a research agent, and reference files covering Titanium architecture, API reference, native how-tos, Alloy MVC, PurgeTSS styling, UI/UX patterns, 2D games, and native sound synthesis.
 
 The reference files are maintained against official documentation whenever an official source exists, so the assistant can retrieve current framework behavior instead of guessing from generic training data.
 
@@ -36,9 +36,9 @@ The fastest way to get started with Claude Code. One command to add the marketpl
 ```
 
 What you get:
-- All 9 TiTools skills (`ti-expert`, `purgetss`, `ti-ui`, `ti-game`, `ti-api`, `ti-guides`, `ti-howtos`, `alloy-guides`, `alloy-howtos`)
+- All 10 TiTools skills (`ti-expert`, `purgetss`, `ti-ui`, `ti-game`, `ti-synthengine`, `ti-api`, `ti-guides`, `ti-howtos`, `alloy-guides`, `alloy-howtos`)
 - ti-pro research agent
-- Session hook that auto-detects Titanium projects (`tiapp.xml`, Alloy, PurgeTSS, `ti.game`)
+- Session hook that auto-detects Titanium projects (`tiapp.xml`, Alloy, PurgeTSS, `ti.game`, `ti.synthengine`)
 - Slash commands: `/ti-check`, `/ti-new-screen`, `/ti-audit`
 - Auto-updates via marketplace (opt-in — see note below)
 
@@ -70,7 +70,7 @@ claude   # or gemini, or codex
 ```
 
 What gets installed:
-- The 9 TiTools skills to `~/.agents/skills/`
+- The 10 TiTools skills to `~/.agents/skills/`
 - ti-pro agent for Claude Code
 - Platform symlinks for Claude Code (Gemini CLI and Codex CLI auto-discover from `~/.agents/skills/` — no symlinks needed)
 - Knowledge index in your project's `AGENTS.md`/`CLAUDE.md`/`GEMINI.md`
@@ -91,7 +91,7 @@ Why NPM?
 | **Knowledge Index** | Not included                               | Included (`titools sync`) |
 | **Auto-updates**    | Marketplace (opt-in, enable in `/plugin`)  | SessionStart hook (daily) |
 | **Slash commands**  | `/ti-check`, `/ti-new-screen`, `/ti-audit` | Same three (`~/.claude/commands/`) |
-| **Session hook**    | Auto-detects Titanium projects (Alloy/Classic, PurgeTSS, `ti.game`) | Auto-update only          |
+| **Session hook**    | Auto-detects Titanium projects (Alloy/Classic, PurgeTSS, `ti.game`, `ti.synthengine`) | Auto-update only          |
 
 Having both installed is fine: the CLI detects an enabled marketplace plugin and skips its own skill symlinks and command copies, so nothing shows up twice. `titools doctor` reports which channel is serving Claude Code.
 
@@ -178,6 +178,7 @@ The knowledge index is based on the latest Titanium SDK documentation. If your p
 | purgetss     | Utility-first styling               | UI styling and animations               |
 | ti-ui        | UI/UX patterns                      | Complex layouts, ListViews, platform UI |
 | ti-game      | 2D games with the `ti.game` module  | Sprites, physics, tile layers, wall jumps, pathfinding, text/performance HUDs, particles, camera |
+| ti-synthengine | Sound design with `ti.synthengine` | Tones, chords, retro/UI effects, alarms, sweeps, patterns, mixing and troubleshooting |
 | ti-api       | Complete Titanium API reference     | Looking up properties, methods, events  |
 | ti-guides    | SDK fundamentals                    | tiapp.xml, Hyperloop, distribution, JDK/Xcode compatibility, release notes |
 | ti-howtos    | Native feature integration          | Location, push, media, platform APIs    |
@@ -185,8 +186,9 @@ The knowledge index is based on the latest Titanium SDK documentation. If your p
 | alloy-howtos | Alloy CLI, configuration, debugging | alloy.jmk, config.json, custom XML tags |
 
 Notes:
-- The first four (`ti-expert`, `purgetss`, `ti-ui`, `ti-game`) are opinionated workflow skills reflecting TiTools' Titanium conventions.
+- The first five (`ti-expert`, `purgetss`, `ti-ui`, `ti-game`, `ti-synthengine`) are specialist workflow skills reflecting TiTools' Titanium conventions and native-module contracts.
 - `ti-game` documents the `ti.game` native module (2D sprite engine on OpenGL ES 2.0, Android and iOS). Its API reference was verified against the module source and tracks upstream `main` (the module ships features ahead of its manifest version); it applies to Alloy and Classic projects alike and does not depend on PurgeTSS.
+- `ti-synthengine` translates aesthetic sound requests into strict, production-ready JavaScript for the cross-platform `ti.synthengine` 1.0.0 module. Seven references preserve the official documentation and an eighth adds curated retro, xylophone, memory-pad, polyphony and timer-ownership recipes; the API contract was cross-checked against both native implementations.
 - The latter five are documentation-mirror skills sourced from the official Titanium SDK docs (`tidev/titanium-docs`) and audited against them via the internal `titools-skill-auditor`.
 - `purgetss` reference files are audited against the official PurgeTSS documentation, but its workflow conventions are opinionated.
 
@@ -198,14 +200,14 @@ In addition to skills, this repository includes sub-agents for Claude Code. Sub-
 
 ### ti-pro
 
-Deep-dive research specialist that preloads the 3 TiTools skills.
+Deep-dive research specialist that can combine the complete 10-skill TiTools catalog.
 
 | Aspect           | Details                                          |
 | ---------------- | ------------------------------------------------ |
 | Location         | `~/.claude/agents/ti-pro.md`                     |
 | Model            | Sonnet (comprehensive analysis)                  |
 | Tools            | Read-only (Read, Grep, Glob)                     |
-| Preloaded Skills | `ti-expert`, `purgetss`, `ti-ui`                 |
+| Preloaded Skills | All 10 skills registered in `lib/config.js`      |
 
 When to use the agent vs skills:
 
@@ -245,9 +247,9 @@ TiTools provides slash commands for common tasks. Both channels ship them: the p
 | `/ti-audit`             | Audit project for anti-patterns, memory leaks, and best practice violations         |
 
 These commands automatically invoke the relevant skills:
-- `/ti-check` reads `tiapp.xml` and reports project health
+- `/ti-check` reads `tiapp.xml`, validates declared native modules, and reports project health
 - `/ti-new-screen` uses `ti-expert` + `purgetss` to create properly structured files
-- `/ti-audit` uses `ti-expert` + `ti-ui` + `purgetss` for comprehensive review
+- `/ti-audit` routes all 10 skills: core Titanium checks always, Alloy/PurgeTSS checks when detected, integration how-tos when used, and `ti-game` / `ti-synthengine` checks when those modules are declared
 
 ---
 
@@ -256,10 +258,10 @@ These commands automatically invoke the relevant skills:
 The plugin includes a session start hook that auto-detects Titanium projects. When you open Claude Code in a directory with `tiapp.xml`, it automatically reports:
 
 ```
-Titanium Alloy + PurgeTSS + ti.game project detected. TiTools skills are available and MUST be used...
+Titanium Alloy + PurgeTSS + ti.game + ti.synthengine project detected. TiTools skills are available and MUST be used...
 ```
 
-It reports Alloy vs Classic, whether PurgeTSS is configured, and whether the project declares the `ti.game` module — a game project also gets a line pointing at the `ti-game` skill.
+It reports Alloy vs Classic, whether PurgeTSS is configured, and whether the project declares `ti.game` or `ti.synthengine`. Each detected native module adds a direct reminder to load its dedicated skill before writing module code.
 
 This ensures Claude knows it's a Titanium project from the first prompt, preventing it from writing generic code.
 
@@ -276,7 +278,7 @@ Skills are automatically activated based on your questions. Just ask naturally:
 The AI will automatically use:
 - `ti-expert` -> Architecture and controller structure
 - `purgetss` -> Styling classes and animations (if PurgeTSS detected)
-- `ti-howtos` from [`tidev/skills`](https://github.com/tidev/skills) (if installed) -> Secure token storage
+- `ti-howtos` -> Secure token storage and native integration guidance
 
 You do not need to call skills explicitly. The AI reads skill descriptions and loads the appropriate knowledge when needed.
 
@@ -290,6 +292,7 @@ All skills include automatic project detection to ensure compatibility:
 | ti-expert | Alloy vs Classic      | Checks for `app/` (Alloy) vs `Resources/` (Classic) structure |
 | ti-ui     | Titanium projects     | Checks for `tiapp.xml` (both Alloy and Classic)               |
 | ti-game   | ti.game module        | Checks for `<module>ti.game</module>` in `tiapp.xml` or `require('ti.game')` |
+| ti-synthengine | ti.synthengine module | Checks for `<module>ti.synthengine</module>` in `tiapp.xml` or `require('ti.synthengine')` |
 
 Why this matters:
 - PurgeTSS suggestions are only provided if PurgeTSS is installed
@@ -298,24 +301,16 @@ Why this matters:
 
 ### Skill hierarchy
 
-`ti-expert` acts as the orchestrator, delegating to specialized skills when needed:
+`ti-expert` is the architectural starting point and coordinates with the rest of the bundled catalog:
 
-```
-                    ┌─────────────────┐
-                    │  ti-expert      │
-                    │  (Start Here)   │
-                    └────────┬────────┘
-                             │
-                ┌────────────┴────────────┐
-                │                         │
-                ▼                         ▼
-        ┌───────────────┐         ┌───────────────┐
-        │   purgetss    │         │    ti-ui      │
-        │   (Styling)   │         │   (UI/UX)     │
-        └───────────────┘         └───────────────┘
-```
+| Scope | Skills |
+| --- | --- |
+| Architecture and UI | `ti-expert`, `ti-ui`, `purgetss` when configured |
+| Native modules | `ti-game`, `ti-synthengine` when declared |
+| Exact SDK/API guidance | `ti-api`, `ti-guides`, `ti-howtos` |
+| Alloy MVC and tooling | `alloy-guides`, `alloy-howtos` for Alloy projects |
 
-For pure API / native-feature how-to / MVC / SDK reference docs, install [`tidev/skills`](https://github.com/tidev/skills) alongside TiTools — its `ti-api`, `ti-guides`, `ti-howtos`, `alloy-guides`, and `alloy-howtos` skills layer below this hierarchy without conflict.
+All ten ship with TiTools; no second skill package is required.
 
 ---
 
@@ -477,6 +472,36 @@ Key rules:
 
 ---
 
+### ti-synthengine
+
+Cross-platform sound design and synthesis with the native `ti.synthengine` 1.0.0 module for Android and iOS.
+
+When it activates:
+- `tiapp.xml` declares `ti.synthengine`, or code calls `require('ti.synthengine')`
+- The app needs generated UI feedback, game cues, retro/chiptune effects, alarms, chords, pads, noise percussion, sweeps, panning, or vibrato
+- A synth call returns `false`, the first sound glitches, a pattern stops, a chord pumps, or output changes after a route switch
+
+Example prompts:
+```
+"Create a short sci-fi laser that sweeps left to right with ti.synthengine."
+"Design a clean two-note success cue for a Titanium button."
+"Build a playable xylophone that can glide across bars without retriggering the same note on every touchmove."
+"Create a layered 12-voice chord and stop its repeating pulse cleanly when the window closes."
+"Why does playTone return false when the object looks valid?"
+"Start the engine safely after my Alloy window lays out and clean it up on close."
+```
+
+Key rules:
+- Option objects are closed contracts. Unsupported keys, invalid types, non-finite values, or broken envelopes reject the whole call
+- Read waveform constants from `synth.getDefaults().waveTypes`; never guess numeric values or option names
+- `playTone` accepts `note` or `frequency`, never both; `playChord` accepts `notes` or `frequencies`, never both
+- `duration` includes attack, the full-level middle, and release, so explicit envelope times must intersect correctly
+- Use `frequencyEnd` for sweeps, `panEnd` for stereo movement, and `lfoFreq`/`lfoDepth` for pitch vibrato
+- Curated recipes cover retro effects, playable xylophone gestures, four-pad memory cues, controlled waveform comparisons, layered chords and cancellable repetition
+- Start after the first layout settles, keep one lifecycle owner, check Boolean returns, and call `shutdown()` on cleanup
+
+---
+
 ## Usage examples and best practices
 
 ### Example prompts
@@ -572,7 +597,7 @@ Behavior depends on where you run it:
 | With `--local` flag        | Installs skills locally to `./.agents/skills/` in the current project |
 
 What it does:
-- Installs the 9 TiTools skills (global or local depending on context)
+- Installs the 10 TiTools skills (global or local depending on context)
 - Installs ti-pro agent for Claude Code
 - Installs the `/ti-check`, `/ti-new-screen` and `/ti-audit` slash commands into `~/.claude/commands/`
 - Detects installed AI platforms and lets you choose which to link (only Claude Code needs platform symlinks; Gemini CLI and Codex CLI auto-discover from `~/.agents/skills/`)
@@ -768,7 +793,7 @@ Then only add `large-title-enabled` per-window as needed:
 </Window>
 ```
 
-This pattern is documented across three TiTools skills: `ti-ui`, `ti-expert`, and `purgetss`. The `ti-api` skill in [`tidev/skills`](https://github.com/tidev/skills) also documents the underlying Window properties.
+This pattern is documented across four bundled TiTools skills: `ti-ui`, `ti-expert`, `purgetss`, and `ti-api`, which covers the underlying Window properties.
 
 ---
 
@@ -779,6 +804,8 @@ This pattern is documented across three TiTools skills: `ti-ui`, `ti-expert`, an
 | ti-expert | Architecture + Implementation | 26 files (patterns, feedback surfaces, file type association, sharing, testing, security, etc.) |
 | purgetss  | Setup + Critical Rules        | 33 files (grid, animations, icons, class-index, SVG pipeline, etc.) |
 | ti-ui     | UI Rules + Platform Diffs     | 14 files (layouts, lists, gestures, etc.)             |
+| ti-game   | Native 2D Game Workflow       | 9 files (API, setup, patterns, recipes, tile maps, debugging, roadmap) |
+| ti-synthengine | Native Sound Synthesis   | 8 files (API, sound design, lifecycle, engine, official examples, curated recipes, recommendations, troubleshooting) |
 
 ---
 

package/agents/ti-pro.md

@@ -1,10 +1,17 @@
 ---
 name: ti-pro
-description: Titanium SDK and Alloy research specialist. Loads the 3 TiTools skills and uses them together to answer research-style questions. Use for codebase analysis, architecture reviews, Titanium SDK implementation research, cross-feature questions, and platform-specific differences. Returns concrete findings with file and line references.
+description: Titanium SDK and Alloy research specialist. Loads the complete TiTools skill catalog and uses the relevant scopes together for research-style questions. Use for codebase analysis, architecture reviews, Titanium SDK implementation research, cross-feature questions, native game or sound modules, and platform-specific differences. Returns concrete findings with file and line references.
 skills:
   - ti-expert
   - purgetss
   - ti-ui
+  - ti-game
+  - ti-synthengine
+  - ti-api
+  - ti-guides
+  - ti-howtos
+  - alloy-guides
+  - alloy-howtos
 tools: Read, Grep, Glob, Bash
 model: sonnet
 ---
@@ -15,13 +22,17 @@ You are a research specialist for Titanium SDK and Alloy mobile development. Wit
 
 ## What You Do
 
-When invoked, you research complex topics by consulting the 3 TiTools skills:
+When invoked, research complex topics by consulting the applicable skills from the complete TiTools catalog:
 
 - `ti-expert` - Architecture, patterns, conventions
 - `purgetss` - Utility-first styling classes (optional add-on; use when the project already has it or the user asks about it)
 - `ti-ui` - UI/UX patterns, layouts, gestures
+- `ti-game` - Native `ti.game` architecture and API when the module is declared
+- `ti-synthengine` - Native sound synthesis and strict `ti.synthengine` contract when the module is declared
+- `ti-api`, `ti-guides`, `ti-howtos` - Exact Titanium APIs, SDK fundamentals and native integrations
+- `alloy-guides`, `alloy-howtos` - Alloy MVC, CLI, configuration and compiler workflows when the project is Alloy
 
-If the user has [`tidev/skills`](https://github.com/tidev/skills) installed alongside TiTools, also consult its doc-based skills (`ti-api`, `ti-guides`, `ti-howtos`, `alloy-guides`, `alloy-howtos`) when API surface, native-feature how-tos, MVC reference, or SDK fundamentals are part of the question.
+Do not force conditional skills onto an unrelated project. State which scopes were applicable and why.
 
 ## Research Process
 
@@ -48,6 +59,8 @@ If the user has [`tidev/skills`](https://github.com/tidev/skills) installed alon
 | `/ti-expert` for architecture guidance       | Inline consultation during development |
 | `/purgetss` to verify a class                | Quick inline reference                 |
 | `/ti-ui` for UI/UX patterns and layouts      | Task-oriented guidance                 |
+| `/ti-game` for a focused native game task    | Task-oriented game implementation      |
+| `/ti-synthengine` for a focused sound task   | Task-oriented sound implementation     |
 | Main conversation for iterative work         | Sub-agents run in isolation            |
 
 ## Response Format

package/commands/ti-audit.md

@@ -3,12 +3,27 @@ name: ti-audit
 description: Audit Titanium project for anti-patterns, memory leaks, and best practice violations
 ---
 
-Audit the current Titanium project by invoking the relevant TiTools skills:
+Audit the current Titanium project by invoking every applicable TiTools skill. First inspect `tiapp.xml` and the project layout so conditional skills are not run against the wrong project type.
 
-1. Invoke `ti-expert` — check for architecture anti-patterns, memory leaks (missing event listener cleanup), and code conventions
-2. Invoke `ti-ui` — check for UI anti-patterns (Ti.UI.SIZE in ListViews, WebView inside TableView, missing accessibility)
-3. If PurgeTSS project, invoke `purgetss` — check for custom TSS that should be utility classes, unsupported classes, padding on Views
-4. Invoke `alloy-guides` — check for proper Alloy patterns (model usage, widget structure)
-5. If the project declares `ti.game`, invoke `ti-game` — check for sprites moved from timers instead of native properties, levels sized from `Ti.Platform.displayCaps` instead of the `resize` event, sprites added one by one instead of in one array, and timers or sounds left running when the window closes
+Core Titanium audit:
+
+1. Invoke `ti-expert` — check architecture, navigation ownership, event/timer cleanup, memory leaks, bridge pressure, testing boundaries, adaptive layouts and code conventions.
+2. Invoke `ti-guides` — check `tiapp.xml`, CommonJS/Hyperloop usage, Titanium CLI/build assumptions, memory and bridge guidance, distribution settings, and toolchain compatibility.
+3. Invoke `ti-api` — verify every audited `Ti.*` API, event, property, constant and third-party module call against its exact signature. Do not report a suspected API defect from memory.
+4. Invoke `ti-ui` when the project creates Titanium UI — check layouts, list performance, event bubbling, gestures, animations, accessibility, orientation and platform-specific UI.
+5. Invoke `ti-howtos` when the project implements a native integration such as location, maps, push, camera, media, SQLite, HTTPClient, WebView, intents, Keychain/iCloud, Hyperloop or CI/CD — audit the complete integration and platform setup, not only the JavaScript call site.
+
+Project-type audit:
+
+6. If the project is Alloy (`app/views/`, `app/controllers/`, `app/styles/`), invoke `alloy-guides` — check controllers, XML/TSS, models, collections, widgets, sync adapters and cleanup patterns.
+7. If the Alloy project uses `alloy.jmk`, `config.json`, `widget.json`, conditional views, custom XML tags or Alloy CLI workflows, invoke `alloy-howtos` — check configuration precedence, build hooks, generated structures and compilation/debugging conventions.
+8. If the project uses PurgeTSS (`purgetss/` or `purgetss/config.cjs`), invoke `purgetss` before evaluating styling — check unsupported utility classes, padding on Views, unnecessary manual TSS, dynamic components, grids, icons and animations.
+
+Native-module audit:
+
+9. If the project declares `ti.game`, invoke `ti-game` — check for sprites moved from timers instead of native properties, levels sized from `Ti.Platform.displayCaps` instead of the `resize` event, sprites added one by one instead of in one array, and timers or sounds left running when the window closes.
+10. If the project declares `ti.synthengine`, invoke `ti-synthengine` — check strict option names and types, mutually exclusive pitch fields, valid envelope intersections, checked Boolean results, one clear lifecycle owner, delayed startup after layout, app-owned timer cancellation, and `shutdown()` cleanup.
+
+If a conditional skill does not apply, record it as `not applicable` with the detected reason instead of inventing findings from it.
 
 Report findings grouped by severity: critical, warning, info.

package/commands/ti-check.md

@@ -9,7 +9,8 @@ Check the current Titanium project and report:
 2. Check if Alloy project (app/views + app/controllers exist)
 3. Check if PurgeTSS is configured (purgetss/config.cjs exists)
 4. Check whether the `ti.game` module is declared in `tiapp.xml` — report its version and whether the module is actually present under `modules/<platform>/ti.game/<version>/` or installed globally
-5. Check for common issues:
+5. Check whether the `ti.synthengine` module is declared in `tiapp.xml` — report its version, verify matching Android/iPhone declarations, and whether the module is present under `modules/<platform>/ti.synthengine/<version>/` or installed globally
+6. Check for common issues:
    - Missing icon files (DefaultIcon.png)
    - Empty modules section in tiapp.xml
    - Outdated SDK version

package/lib/commands/doctor.js

@@ -100,7 +100,9 @@ export async function doctorCommand() {
     }
   }
   const expectedCommands = COMMANDS.length - pluginCommands.length;
-  if (pluginCommands.length === COMMANDS.length) {
+  if (COMMANDS.length === 0) {
+    console.log(`  ${CHECK} Slash commands: none (workflows ship as cross-agent skills)`);
+  } else if (pluginCommands.length === COMMANDS.length) {
     console.log(`  ${CHECK} Slash commands: all ${COMMANDS.length} served by the marketplace plugin`);
   } else if (missingCommands.length === 0) {
     console.log(`  ${CHECK} Slash commands: ${expectedCommands}/${expectedCommands} installed in ~/.claude/commands/`);
@@ -138,10 +140,13 @@ export async function doctorCommand() {
 
     for (const skill of SKILLS) {
       // A skill the marketplace plugin provides is *supposed* to have no mirror
-      // here — the CLI removes it on purpose to avoid a duplicate entry. Counting
-      // it as missing turns a healthy marketplace install into a wall of errors
-      // telling the user to run a command that will correctly do nothing.
-      if (platform.name === 'claude' && pluginProvidesSkill(skill, homeDir)) {
+      // here — the CLI removes it on purpose to avoid a duplicate entry. During
+      // command-to-skill migrations, a same-name command in an older enabled
+      // cache also suppresses the mirror until the marketplace refreshes.
+      if (
+        platform.name === 'claude' &&
+        (pluginProvidesSkill(skill, homeDir) || pluginProvidesCommand(skill, homeDir))
+      ) {
         servedByPlugin.push(skill);
         continue;
       }

package/lib/config.js

@@ -34,6 +34,7 @@ export const SKILLS = [
   'purgetss',
   'ti-ui',
   'ti-game',
+  'ti-synthengine',
   'ti-api',
   'ti-guides',
   'ti-howtos',

package/lib/symlink.js

@@ -83,8 +83,8 @@ async function removePath(path) {
  * @returns {Promise<boolean>} True if the plugin provides this skill
  */
 export async function isClaudePluginSkillInstalled(skillName, baseDir) {
-  const { pluginProvidesSkill } = await import('./claude-plugin.js');
-  return pluginProvidesSkill(skillName, baseDir);
+  const { pluginProvidesSkill, pluginProvidesCommand } = await import('./claude-plugin.js');
+  return pluginProvidesSkill(skillName, baseDir) || pluginProvidesCommand(skillName, baseDir);
 }
 
 /**
@@ -118,8 +118,9 @@ export async function createSkillSymlinks(platformSkillsDir, skills, baseDir) {
   const useRelative = !!baseDir;
 
   for (const skill of skills) {
-    // Skip Claude when the marketplace plugin already provides this skill;
-    // clean up any stale symlink left from a previous CLI install.
+    // Skip Claude when the marketplace plugin already provides this skill or
+    // still provides a same-name legacy command during a command-to-skill
+    // migration; clean up any stale symlink left from a previous CLI install.
     if (isClaudePlatform && await isClaudePluginSkillInstalled(skill, baseDir)) {
       const stalePath = join(platformSkillsDir, skill);
       if (existsSync(stalePath)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@maccesar/titools",
-  "version": "4.16.3",
-  "description": "Titanium SDK skills and agents for AI coding assistants (Claude Code, Gemini CLI, Codex CLI)",
+  "version": "4.17.1",
+  "description": "Titanium SDK skills and agents for AI coding assistants, including native game and sound synthesis modules",
   "main": "lib/index.js",
   "type": "module",
   "bin": {
@@ -25,7 +25,10 @@
     "agents",
     "mobile",
     "ios",
-    "android"
+    "android",
+    "audio",
+    "sound-design",
+    "synthesizer"
   ],
   "author": "César Estrada <maccesar@gmail.com> (https://github.com/macCesar)",
   "license": "MIT",

package/skills/ti-synthengine/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: ti-synthengine
+description: "Use when a Titanium app declares ti.synthengine in tiapp.xml, imports require('ti.synthengine'), or asks for generated tones, chords, patterns, retro/game/UI sounds, alarms, sweeps, vibrato, envelopes, panning, gain staging, or troubleshooting with that native module. Covers Android and iOS contract 1.0.0. Do not use for audio-file playback, streaming music, or unrelated synthesizers."
+---
+
+# ti.synthengine — sound synthesis for Titanium SDK
+
+Act as an audio engineer and mobile sound designer for the native `ti.synthengine` module. Translate an aesthetic request into acoustically reasoned JavaScript that uses only the module's public contract.
+
+This skill is verified against TiSynthEngine **1.0.0** at commit **`6685b81` (2026-08-29)**. Android and iOS expose the same eight public methods, option contracts, defaults, limits, waveform constants, and validation behavior.
+
+## Required workflow
+
+Read the references relevant to the task before proposing code. Do not infer option names from Web Audio, another synthesizer, or general DSP libraries.
+
+| Task | Read first |
+| --- | --- |
+| Any code using a public method, option, default, limit, or return value | [references/api.md](references/api.md) |
+| Design a sound from an aesthetic description | [references/sound-design.md](references/sound-design.md), then [references/recipes.md](references/recipes.md) for a tuned starting point |
+| Build retro/arcade effects, a playable instrument, memory pads, layered chords, timbre comparisons, or cancellable repetition | [references/recipes.md](references/recipes.md), plus [references/api.md](references/api.md) |
+| Learn the official examples for tones, chords, tempo, patterns, noise, validation, startup, and cleanup | [references/examples.md](references/examples.md) |
+| Install the module, start it safely, or manage screen/app cleanup | [references/guide.md](references/guide.md) |
+| Choose a mixing profile, voice count, gain, latency strategy, or understand the signal path | [references/audio-engine.md](references/audio-engine.md), [references/recommendations.md](references/recommendations.md) |
+| Diagnose `false`, silence, glitches, distortion, pattern replacement, or route changes | [references/troubleshooting.md](references/troubleshooting.md), [references/api.md](references/api.md) |
+
+Cite factual guidance with `[source: references/<file>.md]`. If a relevant reference cannot be consulted, prefix the claim with `FROM_MEMORY (unverified):` instead of filling the gap silently.
+
+## Response contract for sound requests
+
+Answer in the user's language and use this order:
+
+1. **Brief acoustic explanation.** Name the waveform, envelope, pitch movement or LFO, stereo movement, and why they create the requested perception.
+2. **Safe initialization when needed.** If the surrounding code does not already own a running engine, show `require`, `getDefaults()`, a checked `startEngine()` call, and appropriate cleanup. For a screen startup, follow the post-layout lifecycle in the guide.
+3. **Production JavaScript.** Return a focused, copyable block with short comments, exact option names, valid types and checked Boolean results.
+
+If the request cannot be represented by this synthesizer—audio-file playback, indefinite loops, per-voice control, streaming, or sample-accurate composition—say so and recommend the appropriate kind of audio engine instead of inventing an API.
+
+## Contract invariants
+
+Start from the installed contract:
+
+```javascript
+var synth = require('ti.synthengine')
+var contract = synth.getDefaults()
+var WAVE = contract.waveTypes
+```
+
+Never hardcode waveform integers when `WAVE.SINE`, `WAVE.SQUARE`, `WAVE.SAWTOOTH`, `WAVE.TRIANGLE`, and `WAVE.NOISE` are available.
+
+- Option dictionaries are closed. Unknown or misspelled keys, wrong types, non-finite numbers, fractional values for integer fields, and out-of-range values make the entire call return `false`.
+- `playTone()` takes at most one pitch source: `note` or `frequency`. If neither is supplied, it defaults to 440 Hz. Never send both.
+- `playChord()` requires exactly one of `notes` or `frequencies`. It accepts `panSpread` or `pans`, but no sweep or LFO fields.
+- Every sounding `playPattern()` step needs exactly one of `note` or `frequency`; a rest uses exactly `rest: true`. Even a `NOISE` step needs a pitch field, although noise ignores its value. Pattern roots do not accept `duration`.
+- `duration` includes attack, the full-level middle, and release. For explicit envelopes, `attack < duration` and `release <= duration - attack`.
+- `pan` and `panEnd` range from -1 to 1. `frequencyEnd` is a linear sweep target. `lfoFreq` is the modulation rate in Hz and `lfoDepth` is absolute pitch deviation in Hz, not cents.
+- `startEngine()`, `playTone()`, `playChord()`, `playPattern()`, and `setVolume()` return `Boolean`; production code must handle rejection where it matters.
+- Only one pattern can remain pending. A new pattern replaces future steps from the previous one. `stopAll()` fades active voices but does not cancel scheduled steps; `shutdown()` does both and frees the stream.
+
+## Acoustic decision guide
+
+Use these as starting regions, then keep every explicit value inside the API limits and the envelope intersection:
+
+| Intent | Starting design |
+| --- | --- |
+| Clean UI click or feedback | `SINE` or `TRIANGLE`, roughly 30–120 ms, 1–5 ms attack, short fitted release |
+| Retro pickup or melody | `SQUARE`, short notes or a rising `playPattern()` |
+| Retro bass | `TRIANGLE`, lower pitch, short attack and controlled release |
+| Hit, hat, explosion texture | `NOISE`, immediate attack and short-to-medium release; layer only when the overlap budget allows |
+| Alarm or urgent cue | `SAWTOOTH`, repeated pitches, a sweep, or vibrato around 4–7 Hz; use larger `lfoDepth` only for an obvious effect |
+| Laser or sci-fi movement | One `frequency` plus `frequencyEnd`, short attack, fitted release, optional `pan` → `panEnd` |
+| Pad or atmosphere | One `playChord()` with `SINE` or `TRIANGLE`, 2000 ms or longer, 300–600 ms attack, 800–1500 ms release when it fits |
+
+A4 is 440 Hz under twelve-tone equal temperament; each octave doubles or halves frequency. Upward sweeps tend to read as activation, reward, or energy gain; downward sweeps tend to read as dismissal, power-down, or impact. Treat pan as supporting detail because many phone speakers collapse the stereo image.
+
+For playable controls, trigger one event when the finger enters a new key, not on every `touchmove`. For simultaneous musical voices, prefer one atomic `playChord()` call; use small cent offsets in the generated frequency array when a layered sound needs beating because the module has no chord-detune option. Cancel app-owned timers before stopping voices or shutting down the engine. [source: references/recipes.md]
+
+## Mixing and lifecycle defaults
+
+- Begin with `mixingProfile: 'conservative'`; use `balanced` mainly for one or two voices, `speakerSafe` for demanding small speakers, and `raw` only when the app owns gain staging.
+- Size `maxVoices` for the largest real overlap, including release tails. Capacity is not loudness.
+- Use one engine owner. On a Titanium screen, start after layout settles and call `shutdown()` when the owner closes.
+- Test on the actual output path. Headphones expose noise and stereo detail; small phone speakers expose weak bass, resonance, and acoustic distortion that a digital limiter cannot repair.
+
+## Before returning code
+
+- Re-read the exact method table in `references/api.md`; remove every unsupported property.
+- Confirm pitch fields are mutually exclusive and numeric values are finite and in range.
+- Compute the envelope intersection explicitly.
+- Use `WAVE` constants from `getDefaults()`.
+- Use `playChord()` for one simultaneous musical event instead of several hotter independent tones.
+- Include startup and cleanup only at the ownership level relevant to the request.
+- Cite the references that support the acoustic and API choices.