@maccesar/titools 4.1.0 → 4.3.0

package/README.md

@@ -92,9 +92,13 @@ Why NPM?
 | **Codex CLI**       | Not available                              | Supported                 |
 | **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` | Not available             |
+| **Slash commands**  | `/ti-check`, `/ti-new-screen`, `/ti-audit` | Same three (`~/.claude/commands/`) |
 | **Session hook**    | Auto-detects Titanium projects             | 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.
+
 Use **Option A** if you only use Claude Code. Use **Option B** if you use multiple AI assistants or want the Knowledge Index feature.
 
 ---
@@ -232,9 +236,12 @@ Key difference:
 
 ---
 
-## Slash Commands (Plugin only)
+## Slash Commands (Claude Code)
 
-When installed as a plugin, TiTools provides slash commands for common tasks:
+TiTools provides slash commands for common tasks. Both channels ship them: the
+plugin serves them from its own cache, and `titools install` copies them into
+`~/.claude/commands/`. If you have both, the CLI detects the plugin and skips its
+own copy so the command does not appear twice in the autocomplete.
 
 | Command                 | Description                                                                         |
 | ----------------------- | ----------------------------------------------------------------------------------- |
@@ -485,7 +492,7 @@ More examples: See [Example Prompts](EXAMPLE-PROMPTS.md) for detailed prompts th
 
 ### titools install
 
-Installs Titanium skills, agents, and platform symlinks.
+Installs Titanium skills, the ti-pro agent, slash commands, and platform symlinks.
 
 ```bash
 titools install [options]
@@ -509,8 +516,10 @@ Behavior depends on where you run it:
 What it does:
 - Installs the 8 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/`)
 - Creates symlinks from `~/.claude/skills/` to the central `~/.agents/skills/`
+- Skips any skill or command already served by an enabled marketplace plugin, and removes a duplicate left by an earlier install
 - Cleans up legacy artifacts (`alloy-expert` skill, `ti-researcher` agent, redundant Gemini/Codex symlinks)
 - If run inside a Titanium project, prompts to run `titools sync` afterward
 - Installs Claude Code SessionStart hook for auto-updates
@@ -557,7 +566,15 @@ Diagnoses installation health.
 titools doctor
 ```
 
-Checks: skill directories exist, symlinks are valid (not broken), agent is installed, hook is configured, cache is readable, Knowledge Index version matches CLI version. Reports issues with fix suggestions.
+Checks: skill directories exist, symlinks are valid (not broken), agent is installed, slash commands are installed, hook is configured, cache is readable, Knowledge Index version matches CLI version. Reports issues with fix suggestions.
+
+It also reports the marketplace plugin's state, which changes what "healthy" means:
+
+| Plugin state                       | What doctor reports                                                     |
+| ---------------------------------- | ----------------------------------------------------------------------- |
+| Enabled                            | Claude Code is served by the plugin — missing mirrors are correct        |
+| Not installed                      | Skills reach Claude Code through npm mirrors — mirrors must be present   |
+| Uninstalled, cache directory left  | Warns and prints the `rm -rf` that clears the leftover                   |
 
 ### titools sync
 

package/bin/titools.js

@@ -26,7 +26,7 @@ program
 // Install command
 program
   .command('install')
-  .description('Install Titanium knowledge packages and platform links')
+  .description('Install Titanium skills, the ti-pro agent, slash commands and platform links')
   .option('-l, --local', 'Install skills locally in the current project')
   .option('-a, --all', 'Install all detected platforms without prompting')
   .option('--path <path>', 'Install to a custom path (skips symlink setup)')
@@ -44,14 +44,14 @@ program
 // Update command
 program
   .command('update')
-  .description('Check for newer CLI versions, then sync installed knowledge packages and agent')
+  .description('Check for newer CLI versions, then sync installed skills, agent and slash commands')
   .option('-l, --local', 'Update local skills in the current project')
   .action(updateCommand);
 
 // Remove command
 program
   .command('remove')
-  .description('Remove Titanium knowledge packages and agent')
+  .description('Remove Titanium skills, the ti-pro agent and slash commands')
   .option('-l, --local', 'Remove local skills from the current project')
   .action(uninstallCommand);
 
@@ -71,7 +71,7 @@ program
 // Doctor command
 program
   .command('doctor')
-  .description('Check installation health and diagnose issues')
+  .description('Check installation health, including marketplace-plugin overlap, and diagnose issues')
   .action(doctorCommand);
 
 // List command

package/commands/ti-audit.md

@@ -0,0 +1,13 @@
+---
+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:
+
+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)
+
+Report findings grouped by severity: critical, warning, info.

package/commands/ti-check.md

@@ -0,0 +1,15 @@
+---
+name: ti-check
+description: Verify Titanium project setup and report issues
+---
+
+Check the current Titanium project and report:
+
+1. Read `tiapp.xml` — report SDK version, app ID, deployment targets
+2. Check if Alloy project (app/views + app/controllers exist)
+3. Check if PurgeTSS is configured (purgetss/config.cjs exists)
+4. Check for common issues:
+   - Missing icon files (DefaultIcon.png)
+   - Empty modules section in tiapp.xml
+   - Outdated SDK version
+5. Report a summary of findings

package/commands/ti-new-screen.md

@@ -0,0 +1,18 @@
+---
+name: ti-new-screen
+description: Create a new Alloy screen (controller + view + style) following project conventions
+argument-hint: "<screenName>"
+---
+
+Create a new Alloy screen with the given name. Before creating files:
+
+1. Invoke the `alloy-guides` skill to follow Alloy MVC patterns
+2. If PurgeTSS is detected (purgetss/ folder exists), invoke the `purgetss` skill — all styling MUST use utility classes in the XML, NOT custom TSS
+3. If PurgeTSS is detected, invoke the `ti-ui` skill for layout patterns
+
+Create these files:
+- `app/views/$ARGUMENTS.xml` — Alloy XML view with PurgeTSS utility classes
+- `app/controllers/$ARGUMENTS.js` — Controller with proper event cleanup
+- `app/styles/$ARGUMENTS.tss` — Empty or minimal (PurgeTSS handles styling)
+
+Follow the existing screens in the project as examples for conventions.

package/lib/claude-plugin.js

@@ -0,0 +1,105 @@
+/**
+ * Detection of the maccesar-titools Claude Code marketplace plugin.
+ *
+ * When the plugin is installed, Claude Code already lists our skills and slash
+ * commands from its plugin cache, so the CLI must not also install its own copy
+ * into ~/.claude/ — that produces duplicate entries in the autocomplete.
+ *
+ * The subtlety, and the reason this lives in its own module: **the cache on disk
+ * does not mean the plugin is installed.** Uninstalling a plugin removes it from
+ * `enabledPlugins` in settings.json but leaves the cache directory behind.
+ * Treating that leftover directory as proof of installation makes the CLI skip
+ * work it should do, which leaves Claude Code with no skills at all and no way
+ * for the user to repair it by re-running install. So the question we answer here
+ * is "is the plugin enabled AND does it carry this file", never just the latter.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import {
+  CLAUDE_PLUGIN_KEY,
+  getClaudePluginSkillsPath,
+  getClaudeSettingsPaths,
+} from './config.js';
+
+/**
+ * Whether Claude Code currently has the titools plugin enabled.
+ * @param {string} baseDir - Optional base directory (defaults to homedir via config)
+ * @returns {boolean} True only when a settings file explicitly enables the plugin
+ */
+export function isClaudePluginEnabled(baseDir) {
+  for (const settingsPath of getClaudeSettingsPaths(baseDir)) {
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      if (settings?.enabledPlugins?.[CLAUDE_PLUGIN_KEY] === true) {
+        return true;
+      }
+    } catch {
+      // Missing or malformed settings: nothing here says the plugin is enabled.
+      // Falling through to `false` is the safe direction — the cost of a wrong
+      // `false` is a duplicate entry, the cost of a wrong `true` is a user with
+      // no skills installed.
+    }
+  }
+  return false;
+}
+
+/**
+ * Whether a plugin cache directory exists at all, regardless of whether the
+ * plugin is enabled. An enabled plugin implies a cache; a cache implies nothing,
+ * because uninstalling leaves it behind. Diagnostics use this to tell "never
+ * installed" apart from "uninstalled, leftovers on disk".
+ * @param {string} baseDir - Optional base directory
+ * @returns {boolean}
+ */
+export function hasClaudePluginCache(baseDir) {
+  return existsSync(getClaudePluginSkillsPath(baseDir));
+}
+
+/**
+ * Whether any cached version of the plugin carries the given file.
+ * @param {string} kind - Subdirectory inside the plugin ('skills' or 'commands')
+ * @param {string} entry - Entry to look for (skill directory or command file)
+ * @param {string} baseDir - Optional base directory
+ * @returns {boolean} True if a cached version contains it
+ */
+function pluginCacheContains(kind, entry, baseDir) {
+  const pluginBase = getClaudePluginSkillsPath(baseDir);
+  if (!existsSync(pluginBase)) return false;
+  try {
+    return readdirSync(pluginBase).some((version) =>
+      existsSync(join(pluginBase, version, kind, entry))
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Whether the installed plugin already provides this skill to Claude Code.
+ * @param {string} skillName - Skill name (e.g. 'ti-expert')
+ * @param {string} baseDir - Optional base directory
+ * @returns {boolean}
+ */
+export function pluginProvidesSkill(skillName, baseDir) {
+  return isClaudePluginEnabled(baseDir) && pluginCacheContains('skills', skillName, baseDir);
+}
+
+/**
+ * Whether the installed plugin already provides this slash command.
+ * @param {string} commandName - Command name without the .md extension
+ * @param {string} baseDir - Optional base directory
+ * @returns {boolean}
+ */
+export function pluginProvidesCommand(commandName, baseDir) {
+  return (
+    isClaudePluginEnabled(baseDir) && pluginCacheContains('commands', `${commandName}.md`, baseDir)
+  );
+}
+
+export default {
+  isClaudePluginEnabled,
+  hasClaudePluginCache,
+  pluginProvidesSkill,
+  pluginProvidesCommand,
+};

package/lib/cleanup.js

@@ -7,8 +7,11 @@ import {
   LEGACY_SKILLS,
   AGENTS,
   LEGACY_AGENTS,
+  COMMANDS,
+  LEGACY_COMMANDS,
   getAgentsSkillsDir,
   getClaudeAgentsDir,
+  getClaudeCommandsDir,
   getCodexSkillsDir,
   getGeminiSkillsDir,
 } from './config.js';
@@ -26,6 +29,11 @@ export function getAgentList({ includeLegacy = true, legacyOnly = false } = {})
   return includeLegacy ? [...AGENTS, ...LEGACY_AGENTS] : [...AGENTS];
 }
 
+export function getCommandList({ includeLegacy = true, legacyOnly = false } = {}) {
+  if (legacyOnly) return [...LEGACY_COMMANDS];
+  return includeLegacy ? [...COMMANDS, ...LEGACY_COMMANDS] : [...COMMANDS];
+}
+
 function removeEntriesAtDir(dir, names, { suffix = '', recursive = true } = {}) {
   const results = { removed: [], failed: [] };
   if (!dir || !existsSync(dir)) return results;
@@ -98,9 +106,16 @@ export function removeAgents(baseDir, options = {}) {
   return removeEntriesAtDir(agentsDir, agentList, { suffix: '.md', recursive: false });
 }
 
+export function removeCommands(baseDir, options = {}) {
+  const commandsDir = getClaudeCommandsDir(baseDir);
+  const commandList = getCommandList(options);
+  return removeEntriesAtDir(commandsDir, commandList, { suffix: '.md', recursive: false });
+}
+
 export function cleanupLegacyArtifacts(baseDir) {
   removeSkills(baseDir, { legacyOnly: true });
   removeAgents(baseDir, { legacyOnly: true });
+  removeCommands(baseDir, { legacyOnly: true });
 
   const platforms = detectPlatforms(baseDir);
   for (const platform of platforms) {
@@ -113,6 +128,7 @@ export function cleanupLegacyArtifacts(baseDir) {
   if (baseDir) {
     removeSkills(undefined, { legacyOnly: true });
     removeAgents(undefined, { legacyOnly: true });
+    removeCommands(undefined, { legacyOnly: true });
     const globalPlatforms = detectPlatforms();
     for (const platform of globalPlatforms) {
       removeLegacySkillSymlinks(platform.skillsDir);
@@ -125,6 +141,7 @@ export function cleanupLegacyArtifacts(baseDir) {
 export default {
   getSkillList,
   getAgentList,
+  getCommandList,
   removeSkillSymlinks,
   removeLegacySkillSymlinks,
   removeCodexRedundantSymlinks,
@@ -133,5 +150,6 @@ export default {
   removeUnselectedSymlinks,
   removeSkills,
   removeAgents,
+  removeCommands,
   cleanupLegacyArtifacts,
 };

package/lib/commands/doctor.js

@@ -9,16 +9,24 @@ import { join } from 'path';
 import os from 'os';
 import {
   SKILLS,
+  COMMANDS,
   PACKAGE_VERSION,
   TITANIUM_KNOWLEDGE_VERSION,
   getAgentsSkillsDir,
   getClaudeAgentsDir,
+  getClaudeCommandsDir,
   getConfigDir,
   getPlatforms,
 } from '../config.js';
 import { hasHook } from '../hooks.js';
 import { readLastCheck } from '../cache.js';
 import { isTitaniumProject, blockExists } from '../utils.js';
+import {
+  isClaudePluginEnabled,
+  hasClaudePluginCache,
+  pluginProvidesSkill,
+  pluginProvidesCommand,
+} from '../claude-plugin.js';
 
 const CHECK = chalk.green('✓');
 const CROSS = chalk.red('✗');
@@ -39,6 +47,7 @@ export async function doctorCommand() {
   const homeDir = os.homedir();
   const skillsDir = getAgentsSkillsDir(homeDir);
   const agentsDir = getClaudeAgentsDir(homeDir);
+  const commandsDir = getClaudeCommandsDir(homeDir);
   const claudeDir = join(homeDir, '.claude');
   const cacheDir = getConfigDir();
   const cwd = process.cwd();
@@ -79,6 +88,27 @@ export async function doctorCommand() {
     issues++;
   }
 
+  // Slash commands check. Like the skills above, commands the marketplace
+  // plugin serves are supposed to be absent from ~/.claude/commands/.
+  const missingCommands = [];
+  const pluginCommands = [];
+  for (const command of COMMANDS) {
+    if (pluginProvidesCommand(command, homeDir)) {
+      pluginCommands.push(command);
+    } else if (!existsSync(join(commandsDir, `${command}.md`))) {
+      missingCommands.push(command);
+    }
+  }
+  const expectedCommands = COMMANDS.length - pluginCommands.length;
+  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/`);
+  } else {
+    console.log(`  ${CROSS} Slash commands: ${expectedCommands - missingCommands.length}/${expectedCommands} installed (missing: ${missingCommands.join(', ')})`);
+    issues += missingCommands.length;
+  }
+
   // Hook check
   if (hasHook(claudeDir)) {
     console.log(`  ${CHECK} Hook: SessionStart configured`);
@@ -104,8 +134,18 @@ export async function doctorCommand() {
   for (const platform of platforms) {
     const missing = [];
     const broken = [];
+    const servedByPlugin = [];
 
     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)) {
+        servedByPlugin.push(skill);
+        continue;
+      }
+
       const linkPath = join(platform.skillsDir, skill);
       try {
         const stat = lstatSync(linkPath);
@@ -121,15 +161,26 @@ export async function doctorCommand() {
       }
     }
 
-    const linkedCount = SKILLS.length - missing.length - broken.length;
+    const expected = SKILLS.length - servedByPlugin.length;
+    const linkedCount = expected - missing.length - broken.length;
+    const pluginNote =
+      servedByPlugin.length > 0
+        ? chalk.dim(` (+${servedByPlugin.length} served by the marketplace plugin)`)
+        : '';
 
     if (missing.length === 0 && broken.length === 0) {
-      console.log(`    ${CHECK} ${platform.displayName}: ${SKILLS.length}/${SKILLS.length} skills linked`);
+      const summary =
+        expected === 0
+          ? `all ${servedByPlugin.length} skills served by the marketplace plugin`
+          : `${linkedCount}/${expected} skills linked${pluginNote}`;
+      console.log(`    ${CHECK} ${platform.displayName}: ${summary}`);
     } else {
       const problems = [];
       if (missing.length > 0) problems.push(`missing: ${missing.join(', ')}`);
       if (broken.length > 0) problems.push(`broken: ${broken.join(', ')}`);
-      console.log(`    ${CROSS} ${platform.displayName}: ${linkedCount}/${SKILLS.length} skills linked (${problems.join('; ')})`);
+      console.log(
+        `    ${CROSS} ${platform.displayName}: ${linkedCount}/${expected} skills linked${pluginNote} (${problems.join('; ')})`
+      );
       issues += missing.length + broken.length;
 
       // Collect symlink issues for detailed report
@@ -142,6 +193,27 @@ export async function doctorCommand() {
     }
   }
 
+  // Marketplace plugin
+  //
+  // Worth its own section because the two channels look identical from the
+  // outside and produce opposite expectations: with the plugin enabled, absent
+  // mirrors are correct; without it, absent mirrors mean no skills at all.
+  console.log('');
+  console.log('  Marketplace plugin:');
+  const pluginEnabled = isClaudePluginEnabled(homeDir);
+  const pluginCached = hasClaudePluginCache(homeDir);
+
+  if (pluginEnabled) {
+    console.log(`    ${CHECK} Enabled — Claude Code is served by the plugin, mirrors intentionally absent`);
+  } else if (pluginCached) {
+    console.log(`    ${WARN} Not enabled, but a cache directory remains from a previous install`);
+    console.log(`      ${chalk.dim('Harmless on this version, which requires the plugin to be enabled.')}`);
+    console.log(`      ${chalk.dim('Remove it with:')}`);
+    console.log(`      ${chalk.cyan('rm -rf ~/.claude/plugins/cache/maccesar-titools')}`);
+  } else {
+    console.log(`    ${CHECK} Not installed — skills reach Claude Code through npm mirrors`);
+  }
+
   // Symlink issues detail
   if (symlinkIssues.length > 0) {
     console.log('');

package/lib/commands/skills.js

@@ -22,6 +22,7 @@ import {
   removeLegacySkillSymlinks,
   removeSkills,
   removeAgents,
+  removeCommands,
   removeUnselectedSkills,
   removeUnselectedSymlinks,
   cleanupLegacyArtifacts,
@@ -29,6 +30,7 @@ import {
 import {
   installSkills,
   installAgents,
+  installCommands,
   getLocalRepoDir,
 } from '../installer.js';
 import { agentsCommand } from './agents.js';
@@ -117,10 +119,15 @@ export async function skillsCommand(options) {
     chalk.dim('(agentskills.io standard)')
   );
   console.log(
-    '  ' + chalk.dim('Read directly by Gemini, Codex, Cursor, Cline, Amp, GitHub Copilot, +more.')
+    '  ' + chalk.green('✓'),
+    chalk.dim('Gemini, Codex, Cursor, Cline, Amp, GitHub Copilot +more read it directly —')
   );
+  console.log('    ' + chalk.dim('nothing else to configure for them.'));
   console.log(
-    '  ' + chalk.dim('Below: extra symlink mirrors for Claude Code.')
+    '  ' + chalk.dim('Claude Code needs symlink mirrors, plus the ti-pro agent and the')
+  );
+  console.log(
+    '  ' + chalk.dim('/ti-check, /ti-new-screen and /ti-audit slash commands — created below.')
   );
   console.log('');
 
@@ -151,9 +158,17 @@ export async function skillsCommand(options) {
   }
 
   // Show detected platforms
+  // Only assistants that need TiTools-managed mirrors appear here, so a bare
+  // "Claude Code detected" reads as if the others were looked for and not found.
+  // They were never looked for: Gemini, Codex and the rest read
+  // ~/.agents/skills/ directly and are already served by the install itself.
   if (detectedPlatforms.length > 0) {
     for (const platform of detectedPlatforms) {
-      console.log(chalk.green('✓'), `${platform.displayName} detected`);
+      console.log(
+        chalk.green('✓'),
+        `${platform.displayName} detected`,
+        chalk.dim('— needs mirrors, linked below')
+      );
     }
     console.log('');
   } else if (isLocal) {
@@ -315,6 +330,22 @@ export async function skillsCommand(options) {
         } else {
           spinner.info('No agents to install (Claude Code not detected)');
         }
+        // Install slash commands (/ti-check, /ti-new-screen, /ti-audit).
+        // Claude Code only — they live in ~/.claude/commands/ and are skipped
+        // when the marketplace plugin already serves them.
+        spinner.start('Installing slash commands...');
+        const commandsResult = await installCommands(repoDir, baseDir);
+        if (commandsResult.installed.length > 0) {
+          spinner.succeed(
+            `${commandsResult.installed.length} slash command${commandsResult.installed.length !== 1 ? 's' : ''} installed`
+          );
+        } else if (commandsResult.skipped.length > 0) {
+          spinner.info(
+            `${commandsResult.skipped.length} slash command${commandsResult.skipped.length !== 1 ? 's' : ''} already provided by the marketplace plugin`
+          );
+        } else {
+          spinner.info('No slash commands to install');
+        }
       } else {
         spinner.start('Removing agents...');
         const agentsResult = removeAgents(baseDir);
@@ -323,6 +354,13 @@ export async function skillsCommand(options) {
         } else {
           spinner.info('No agents to remove');
         }
+
+        // Slash commands are Claude-only, so they follow the agents: if Claude
+        // is not among the selected platforms, nothing should be left behind.
+        const commandsResult = removeCommands(baseDir);
+        if (commandsResult.removed.length > 0) {
+          spinner.succeed('Slash commands removed');
+        }
       }
 
       // Create symlinks for selected platforms
@@ -337,11 +375,22 @@ export async function skillsCommand(options) {
           skillsToInstall,
           baseDir
         );
-        if (symlinkResult.linked.length === skillsToInstall.length) {
-          spinner.succeed(`${platform.displayName}: Skills linked`);
+        // Skills the marketplace plugin already serves are skipped on purpose,
+        // so they must not count against the expected total — otherwise a
+        // healthy install with the plugin enabled reports a warning.
+        const expected = skillsToInstall.length - symlinkResult.skipped.length;
+        const pluginNote = symlinkResult.skipped.length > 0
+          ? ` (${symlinkResult.skipped.length} served by the marketplace plugin)`
+          : '';
+        if (expected === 0) {
+          spinner.info(
+            `${platform.displayName}: all skills served by the marketplace plugin`
+          );
+        } else if (symlinkResult.linked.length === expected) {
+          spinner.succeed(`${platform.displayName}: Skills linked${pluginNote}`);
         } else {
           spinner.warn(
-            `${platform.displayName}: ${symlinkResult.linked.length}/${skillsToInstall.length} skills linked`
+            `${platform.displayName}: ${symlinkResult.linked.length}/${expected} skills linked${pluginNote}`
           );
         }
       }
@@ -357,6 +406,7 @@ export async function skillsCommand(options) {
       }
     } else {
       const agentsResult = removeAgents(baseDir);
+      const commandsResult = removeCommands(baseDir);
       const skillsResult = removeSkills(baseDir);
       const platformResults = detectedPlatforms.map((platform) => {
         const symlinkResult = removeSkillSymlinks(platform.skillsDir);
@@ -379,6 +429,12 @@ export async function skillsCommand(options) {
         console.log(chalk.gray('ℹ'), 'No agents to remove');
       }
 
+      if (commandsResult.removed.length > 0) {
+        console.log(chalk.green('✓'), `${commandsResult.removed.length} slash commands removed`);
+      } else {
+        console.log(chalk.gray('ℹ'), 'No slash commands to remove');
+      }
+
       for (const result of platformResults) {
         if (result.removedCount > 0) {
           console.log(chalk.green('✓'), `${result.displayName}: Skills unlinked`);
@@ -423,6 +479,10 @@ export async function skillsCommand(options) {
           '  ' + chalk.dim('• symlinked: ') +
           'Claude Code ' + chalk.dim('(~/.claude/skills/)')
         );
+        console.log(
+          '  ' + chalk.dim('• commands:  ') +
+          '/ti-check, /ti-new-screen, /ti-audit ' + chalk.dim('(~/.claude/commands/)')
+        );
       }
     }
     console.log('');