tdoms-mcp 0.7.0 → 0.8.3

package/README.md

@@ -70,7 +70,34 @@ Restart or reload the agent's MCP servers after changing the configuration.
 
 The package includes a portable developer skill at `skills/tdoms-mcp-routing`. Its `SKILL.md` teaches agents how to select core, full-profile, or Octo tools; discover site-specific values; perform guarded task, source, compile, checkout, promote, transfer, branch, and approval workflows; and verify final TD/OMS state.
 
-Agents that support `SKILL.md` folders can register that directory using their normal skill installation mechanism. The skill contains no credentials, connection profiles, organization-specific values, or personal information. Runtime tool schemas and values returned by the connected TD/OMS server remain authoritative.
+The CLI and local UI can install the complete skill folder for detected IBM Bob, Codex, Claude Code, VS Code Copilot, Kiro, and Gemini CLI installations. The skill contains no credentials, connection profiles, organization-specific values, or personal information. Runtime tool schemas and values returned by the connected TD/OMS server remain authoritative.
+
+List the native skill targets and their installation status:
+
+```shell
+tdoms-mcp skills
+```
+
+Install or update the skill for one agent. User scope makes it available across that agent's projects; workspace scope installs it only in the current project:
+
+```shell
+tdoms-mcp install-skill ibm-bob --scope user --confirm
+tdoms-mcp install-skill codex --scope user --confirm
+tdoms-mcp install-skill claude-code --scope workspace --confirm
+tdoms-mcp install-skill vscode --scope workspace --confirm
+tdoms-mcp install-skill kiro --scope user --confirm
+tdoms-mcp install-skill gemini-cli --scope user --confirm
+```
+
+Install or update the skill for every detected compatible agent:
+
+```shell
+tdoms-mcp install-detected-skills --scope user --confirm
+```
+
+The Agent Setup page in `tdoms-mcp ui` provides the same actions with User skill and Workspace skill scope controls. Existing skill folders are timestamped and backed up before replacement, concurrent installs are locked, and a failed replacement restores the prior folder. Bob users must enable Advanced mode; existing agent sessions may need to be restarted or reloaded after installation. Claude Desktop chat requires a ZIP upload to **Customize > Skills**; its row provides a correctly packaged download instead of reporting a local folder copy as installed.
+
+The **Codex** row covers the Codex desktop app, CLI, and VS Code extension through `~/.agents/skills`. Restart Codex or reload the VS Code window and start a new task if a newly installed skill is not visible. The **Visual Studio Code** skill action installs for every compatible extension it detects: Codex through `~/.agents/skills`, Claude Code through `~/.claude/skills`, and GitHub Copilot through `~/.copilot/skills`. Use `/skills` in agents that expose that menu, or invoke the skill by name in Codex and Claude Code.
 
 Detect supported local clients from the installed command:
 
@@ -101,6 +128,8 @@ Detection and installation are environment-local. Running the installer on Windo
 
 Client installation never copies TD/OMS passwords or tokens into agent configuration. It registers only the local stdio command and the `core` tool profile. Existing files are backed up, writes are atomic, invalid JSON is rejected, and failed client updates are restored.
 
+MCP and skill installation are separate on purpose: the MCP provides live TD/OMS tools, while the skill teaches an agent how to route requests and perform guarded change-management workflows. Install both for the complete experience.
+
 ## Core Workflow
 
 The default profile exposes seven tools:
@@ -138,8 +167,13 @@ All tools that can change TD/OMS require explicit confirmation. `tdoms_call_api`
 ```text
 tdoms-mcp ui                              Open the local connection and agent setup UI
 tdoms-mcp clients                         List detected MCP-capable agents
+tdoms-mcp skills                          List native skill targets and status
 tdoms-mcp install-client <id> --confirm   Configure one detected agent
 tdoms-mcp install-detected --confirm      Configure all detected agents
+tdoms-mcp install-skill <id> --scope user --confirm
+                                          Install a skill for one detected agent
+tdoms-mcp install-detected-skills --scope user --confirm
+                                          Install skills for all compatible agents
 tdoms-mcp mcp                             Start the core stdio MCP server
 tdoms-mcp mcp --profile full              Start the complete tool profile
 tdoms-mcp smoke                           Check local configuration without connecting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdoms-mcp",
-  "version": "0.7.0",
+  "version": "0.8.3",
   "description": "Agent-neutral MCP server for TD/OMS change-management workflows.",
   "type": "module",
   "license": "MIT",
@@ -37,6 +37,8 @@
     "secure-storage": "node src/index.js secure-storage",
     "clients": "node src/index.js clients",
     "clients:install": "node src/index.js install-detected --confirm",
+    "skills": "node src/index.js skills",
+    "skills:install": "node src/index.js install-detected-skills --scope user --confirm",
     "test": "node --test"
   },
   "dependencies": {
@@ -44,6 +46,7 @@
     "express": "^4.19.2",
     "jsonc-parser": "^3.3.1",
     "lucide-static": "^1.24.0",
+    "yazl": "^3.3.1",
     "zod": "^4.1.12"
   },
   "engines": {

package/src/client-manager.js

@@ -1,30 +1,38 @@
 import { execFile } from "node:child_process";
+import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { applyEdits, modify, parse } from "jsonc-parser";
+import { ZipFile } from "yazl";
 import { atomicWriteFile, withFileLock } from "./storage-utils.js";
 
 const execFileAsync = promisify(execFile);
 const SERVER_NAME = "tdoms";
+const SKILL_NAME = "tdoms-mcp-routing";
 const DEFAULT_SERVER_ENTRY = fileURLToPath(new URL("./index.js", import.meta.url));
+const DEFAULT_SKILL_ROOT = fileURLToPath(new URL(`../skills/${SKILL_NAME}`, import.meta.url));
 
 export class ClientManager {
   constructor({
     env = process.env,
     platform = process.platform,
     homedir = os.homedir(),
+    workspace = process.cwd(),
     nodeCommand = process.execPath,
     serverEntry = DEFAULT_SERVER_ENTRY,
+    skillRoot = DEFAULT_SKILL_ROOT,
     runner = runExecutable
   } = {}) {
     this.env = env;
     this.platform = platform;
     this.homedir = homedir;
+    this.workspace = path.resolve(workspace);
     this.nodeCommand = nodeCommand;
     this.serverEntry = serverEntry;
+    this.skillRoot = skillRoot;
     this.runner = runner;
     this.runtime = describeRuntime(platform, env);
   }
@@ -36,6 +44,7 @@ export class ClientManager {
       const detectedByConfig = await anyPathExists(definition.configPaths);
       const configured = await isConfigured(definition);
       const detected = Boolean(executable || detectedByConfig || await anyPathExists(definition.appCandidates));
+      const skill = await inspectSkill(definition.skill, this.skillRoot);
       return {
         id: definition.id,
         name: definition.name,
@@ -48,11 +57,91 @@ export class ClientManager {
         strategy: definition.strategy,
         environment: this.runtime,
         restartRequired: definition.restartRequired,
-        status: configured ? "configured" : detected ? "detected" : "not-detected"
+        status: configured ? "configured" : detected ? "detected" : "not-detected",
+        skill
       };
     }));
   }
 
+  async installSkill(id, { confirm = false, scope = "user" } = {}) {
+    if (confirm !== true) {
+      throw new Error("Refusing to install an agent skill without confirm: true.");
+    }
+    if (!["user", "workspace"].includes(scope)) {
+      throw new Error("Skill scope must be either user or workspace.");
+    }
+
+    const definition = (await this.#definitions()).find((item) => item.id === id);
+    if (!definition) throw new Error(`Unsupported MCP client: ${id}`);
+    if (!definition.skill.supported) {
+      throw new Error(`${definition.name} does not have a verified filesystem skill installer. ${definition.skill.guidance}`.trim());
+    }
+    const detected = Boolean(
+      await firstExistingFile(definition.executableCandidates)
+      || await anyPathExists(definition.configPaths)
+      || await anyPathExists(definition.appCandidates)
+    );
+    if (!detected) throw new Error(`${definition.name} is not installed in ${this.runtime.label}.`);
+
+    const targets = skillTargets(definition.skill, scope);
+    const results = [];
+    for (const target of targets) {
+      results.push({
+        ...target,
+        ...await installSkillDirectory(this.skillRoot, target.path, this.platform)
+      });
+    }
+    return {
+      ok: true,
+      clientId: definition.id,
+      clientName: definition.name,
+      scope,
+      skillName: SKILL_NAME,
+      skillPath: results[0].path,
+      skillPaths: results.map((result) => result.path),
+      backupPath: results[0].backupPath,
+      backupPaths: results.map((result) => result.backupPath).filter(Boolean),
+      targets: results,
+      installed: true,
+      current: true,
+      restartRequired: definition.skill.restartRequired
+    };
+  }
+
+  async createSkillArchive() {
+    if (!await pathExists(path.join(this.skillRoot, "SKILL.md"))) {
+      throw new Error(`Bundled skill is incomplete: ${this.skillRoot}`);
+    }
+    return createZipArchive(this.skillRoot);
+  }
+
+  async installDetectedSkills({ confirm = false, scope = "user" } = {}) {
+    if (confirm !== true) {
+      throw new Error("Refusing to install agent skills without confirm: true.");
+    }
+    if (!["user", "workspace"].includes(scope)) {
+      throw new Error("Skill scope must be either user or workspace.");
+    }
+    const clients = await this.listClients();
+    const targets = clients.filter((client) => client.detected && client.skill.supported && !client.skill[scope].current);
+    const results = [];
+    for (const client of targets) {
+      try {
+        results.push(await this.installSkill(client.id, { confirm: true, scope }));
+      } catch (error) {
+        results.push({ ok: false, clientId: client.id, clientName: client.name, error: error.message });
+      }
+    }
+    return {
+      ok: results.every((result) => result.ok),
+      environment: this.runtime,
+      scope,
+      installed: results.filter((result) => result.ok).length,
+      failed: results.filter((result) => !result.ok).length,
+      results
+    };
+  }
+
   async installDetected({ confirm = false } = {}) {
     if (confirm !== true) {
       throw new Error("Refusing to modify MCP client configurations without confirm: true.");
@@ -157,6 +246,7 @@ export class ClientManager {
     const claudeDesktopCodeVersions = await extensionDirectories(paths.claudeDesktopCodeRoot);
     const codexExtension = newestMatching(vscodeExtensions, "openai.chatgpt-");
     const claudeExtension = newestMatching(vscodeExtensions, "anthropic.claude-code-");
+    const copilotExtension = newestMatching(vscodeExtensions, "github.copilot-");
     const claudeStorePackage = newestMatching(windowsPackages, "Claude_");
     const claudeDesktopCodeVersion = newestMatching(claudeDesktopCodeVersions, "");
     const claudeDesktopConfig = claudeStorePackage
@@ -164,7 +254,7 @@ export class ClientManager {
       : paths.claudeDesktopConfig;
     const commandCandidates = async (name, fixed = []) => compact([...fixed, await findOnPath(name, this.platform, this.env)]);
 
-    return [
+    const definitions = [
       {
         id: "ibm-bob",
         name: "IBM Bob",
@@ -313,6 +403,261 @@ export class ClientManager {
         restartRequired: true
       }
     ];
+    return definitions.map((definition) => ({
+      ...definition,
+      skill: skillDefinition(definition.id, this.homedir, this.workspace, {
+        hasVsCodeCodex: Boolean(codexExtension),
+        hasVsCodeClaude: Boolean(claudeExtension),
+        hasVsCodeCopilot: Boolean(copilotExtension)
+      })
+    }));
+  }
+}
+
+function skillDefinition(clientId, home, workspace, {
+  hasVsCodeCodex = false,
+  hasVsCodeClaude = false,
+  hasVsCodeCopilot = false
+} = {}) {
+  const definitions = {
+    "ibm-bob": {
+      userPath: path.join(home, ".bob", "skills", SKILL_NAME),
+      workspacePath: path.join(workspace, ".bob", "skills", SKILL_NAME),
+      restartRequired: false,
+      guidance: "IBM Bob must be in Advanced mode before the skill appears."
+    },
+    codex: {
+      userPath: path.join(home, ".agents", "skills", SKILL_NAME),
+      workspacePath: path.join(workspace, ".agents", "skills", SKILL_NAME),
+      restartRequired: true,
+      guidance: "Start a new Codex session after installation."
+    },
+    "claude-code": {
+      userPath: path.join(home, ".claude", "skills", SKILL_NAME),
+      workspacePath: path.join(workspace, ".claude", "skills", SKILL_NAME),
+      restartRequired: true,
+      guidance: "Start a new Claude Code session after installation."
+    },
+    vscode: {
+      userPath: path.join(home, ".copilot", "skills", SKILL_NAME),
+      workspacePath: path.join(workspace, ".github", "skills", SKILL_NAME),
+      restartRequired: true,
+      guidance: "Reload the VS Code window or start a new chat after installation."
+    },
+    "gemini-cli": {
+      userPath: path.join(home, ".gemini", "skills", SKILL_NAME),
+      workspacePath: path.join(workspace, ".gemini", "skills", SKILL_NAME),
+      restartRequired: false,
+      guidance: "Run /skills reload in an existing Gemini CLI session."
+    },
+    kiro: {
+      userPath: path.join(home, ".kiro", "skills", SKILL_NAME),
+      workspacePath: path.join(workspace, ".kiro", "skills", SKILL_NAME),
+      restartRequired: false,
+      guidance: "Kiro detects skills in its Agent Steering & Skills panel and as slash commands."
+    }
+  };
+  if (clientId === "vscode") {
+    const userTargets = compact([
+      hasVsCodeCodex && { label: "Codex", path: path.join(home, ".agents", "skills", SKILL_NAME) },
+      hasVsCodeClaude && { label: "Claude Code", path: path.join(home, ".claude", "skills", SKILL_NAME) },
+      hasVsCodeCopilot && { label: "GitHub Copilot", path: path.join(home, ".copilot", "skills", SKILL_NAME) }
+    ]);
+    const workspaceTargets = compact([
+      hasVsCodeCodex && { label: "Codex", path: path.join(workspace, ".agents", "skills", SKILL_NAME) },
+      hasVsCodeClaude && { label: "Claude Code", path: path.join(workspace, ".claude", "skills", SKILL_NAME) },
+      hasVsCodeCopilot && { label: "GitHub Copilot", path: path.join(workspace, ".github", "skills", SKILL_NAME) }
+    ]);
+    if (!userTargets.length) {
+      return {
+        supported: false,
+        guidance: "No compatible Codex, Claude Code, or GitHub Copilot extension was detected in VS Code."
+      };
+    }
+    return {
+      supported: true,
+      userTargets,
+      workspaceTargets,
+      restartRequired: true,
+      guidance: `Installs for detected VS Code agents: ${userTargets.map((target) => target.label).join(", ")}.`
+    };
+  }
+  if (definitions[clientId]) return { supported: true, ...definitions[clientId] };
+  if (clientId === "claude-desktop") {
+    return {
+      supported: false,
+      downloadable: true,
+      guidance: "Download the ZIP, then use Customize > Skills > Create skill > Upload a skill in Claude Desktop."
+    };
+  }
+  return { supported: false, guidance: "No verified native Agent Skills directory is available for this client." };
+}
+
+async function inspectSkill(definition, sourceRoot) {
+  if (!definition.supported) {
+    return { supported: false, downloadable: definition.downloadable === true, guidance: definition.guidance };
+  }
+  const inspect = async (target) => {
+    const installed = await pathExists(path.join(target.path, "SKILL.md"));
+    return {
+      ...target,
+      installed,
+      current: installed && await skillFilesMatch(sourceRoot, target.path)
+    };
+  };
+  const inspectScope = async (scope) => {
+    const targets = await Promise.all(skillTargets(definition, scope).map(inspect));
+    return {
+      path: targets[0]?.path,
+      paths: targets.map((target) => target.path),
+      installed: targets.length > 0 && targets.every((target) => target.installed),
+      installedAny: targets.some((target) => target.installed),
+      current: targets.length > 0 && targets.every((target) => target.current),
+      targets
+    };
+  };
+  return {
+    supported: true,
+    guidance: definition.guidance,
+    restartRequired: definition.restartRequired,
+    user: await inspectScope("user"),
+    workspace: await inspectScope("workspace")
+  };
+}
+
+function skillTargets(definition, scope) {
+  const configured = definition[`${scope}Targets`];
+  if (configured?.length) {
+    const seen = new Set();
+    return configured.filter((target) => {
+      const normalized = path.resolve(target.path).toLowerCase();
+      if (seen.has(normalized)) return false;
+      seen.add(normalized);
+      return true;
+    });
+  }
+  const skillPath = definition[`${scope}Path`];
+  return skillPath ? [{ label: definition.label || "Agent", path: skillPath }] : [];
+}
+
+async function installSkillDirectory(source, destination, platform) {
+  if (!await pathExists(path.join(source, "SKILL.md"))) {
+    throw new Error(`Bundled skill is incomplete: ${source}`);
+  }
+  if (path.basename(destination) !== SKILL_NAME) {
+    throw new Error(`Refusing to write an unexpected skill destination: ${destination}`);
+  }
+
+  const parent = path.dirname(destination);
+  await fs.mkdir(parent, { recursive: true });
+  return withFileLock(path.join(parent, `.${SKILL_NAME}.install`), async () => {
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const staged = path.join(parent, `.${SKILL_NAME}.${process.pid}.${crypto.randomUUID()}.tmp`);
+    const rollback = path.join(parent, `.${SKILL_NAME}.${process.pid}.${crypto.randomUUID()}.rollback`);
+    const existed = await pathExists(destination);
+    const backupPath = existed ? `${destination}.tdoms-backup-${stamp}` : undefined;
+    if (platform === "win32") {
+      if (backupPath) await fs.cp(destination, backupPath, { recursive: true, errorOnExist: true });
+      try {
+        await fs.cp(source, destination, { recursive: true, force: true });
+        if (!await skillFilesMatch(source, destination)) {
+          throw new Error("The copied skill did not pass verification.");
+        }
+        return { backupPath };
+      } catch (error) {
+        if (backupPath) {
+          try {
+            await fs.cp(backupPath, destination, { recursive: true, force: true });
+          } catch (restoreError) {
+            throw new Error(`${error.message} The backup remains at ${backupPath} because automatic restoration failed: ${restoreError.message}`);
+          }
+        } else {
+          await fs.rm(destination, { recursive: true, force: true }).catch(() => {});
+        }
+        throw error;
+      }
+    }
+
+    try {
+      await fs.cp(source, staged, { recursive: true, errorOnExist: true });
+      if (backupPath) await fs.cp(destination, backupPath, { recursive: true, errorOnExist: true });
+      if (existed) await renameDirectory(destination, rollback);
+      await renameDirectory(staged, destination);
+      await fs.rm(rollback, { recursive: true, force: true });
+      return { backupPath };
+    } catch (error) {
+      await fs.rm(staged, { recursive: true, force: true }).catch(() => {});
+      if (await pathExists(rollback) && !await pathExists(destination)) {
+        try {
+          await renameDirectory(rollback, destination);
+        } catch (restoreError) {
+          throw new Error(`${error.message} The previous skill remains at ${rollback} because automatic restoration failed: ${restoreError.message}`);
+        }
+      }
+      throw error;
+    }
+  }, { privateDirectory: false });
+}
+
+async function skillFilesMatch(source, destination) {
+  async function compare(sourceDirectory, destinationDirectory) {
+    const entries = await fs.readdir(sourceDirectory, { withFileTypes: true });
+    for (const entry of entries) {
+      const sourcePath = path.join(sourceDirectory, entry.name);
+      const destinationPath = path.join(destinationDirectory, entry.name);
+      if (entry.isDirectory()) {
+        if (!await pathExists(destinationPath) || !await compare(sourcePath, destinationPath)) return false;
+      } else if (entry.isFile()) {
+        try {
+          const [sourceContent, destinationContent] = await Promise.all([
+            fs.readFile(sourcePath),
+            fs.readFile(destinationPath)
+          ]);
+          if (!sourceContent.equals(destinationContent)) return false;
+        } catch {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+  return compare(source, destination).catch(() => false);
+}
+
+async function createZipArchive(source) {
+  const zip = new ZipFile();
+  async function addDirectory(directory, relative = "") {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const relativePath = path.posix.join(relative, entry.name);
+      const absolutePath = path.join(directory, entry.name);
+      if (entry.isDirectory()) await addDirectory(absolutePath, relativePath);
+      else if (entry.isFile()) zip.addFile(absolutePath, path.posix.join(SKILL_NAME, relativePath));
+      else throw new Error(`Unsupported entry in skill directory: ${absolutePath}`);
+    }
+  }
+  await addDirectory(source);
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    zip.outputStream.on("data", (chunk) => chunks.push(chunk));
+    zip.outputStream.on("error", reject);
+    zip.outputStream.on("end", () => resolve(Buffer.concat(chunks)));
+    zip.end();
+  });
+}
+
+async function renameDirectory(source, destination) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    try {
+      await fs.rename(source, destination);
+      return;
+    } catch (error) {
+      if (!["EACCES", "EBUSY", "EPERM"].includes(error.code) || attempt === 19) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 10 + attempt * 5));
+    }
   }
 }
 

package/src/index.js

@@ -53,6 +53,15 @@ async function main() {
     return;
   }
 
+  if (command === "skills") {
+    const clients = await clientManager.listClients();
+    console.log(JSON.stringify({
+      environment: clients[0]?.environment,
+      skills: clients.map(({ id, name, detected, skill }) => ({ id, name, detected, skill }))
+    }, null, 2));
+    return;
+  }
+
   if (command === "install-client") {
     const clientId = process.argv[3];
     if (!clientId) throw new Error("Client id is required. Run `tdoms-mcp clients` to list detected clients.");
@@ -68,6 +77,27 @@ async function main() {
     return;
   }
 
+  if (command === "install-skill") {
+    const clientId = process.argv[3];
+    if (!clientId) throw new Error("Client id is required. Run `tdoms-mcp skills` to list skill targets.");
+    const result = await clientManager.installSkill(clientId, {
+      confirm: process.argv.includes("--confirm"),
+      scope: flagValue("--scope") || "user"
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (command === "install-detected-skills") {
+    const result = await clientManager.installDetectedSkills({
+      confirm: process.argv.includes("--confirm"),
+      scope: flagValue("--scope") || "user"
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
+
   if (command === "mcp") {
     await startMcpServer({ store, profile });
     return;
@@ -84,14 +114,22 @@ function printHelp(write = console.log) {
 Usage:
   tdoms-mcp ui
   tdoms-mcp clients
+  tdoms-mcp skills
   tdoms-mcp install-client <id> --confirm
   tdoms-mcp install-detected --confirm
+  tdoms-mcp install-skill <id> [--scope user|workspace] --confirm
+  tdoms-mcp install-detected-skills [--scope user|workspace] --confirm
   tdoms-mcp mcp [--profile core|full]
   tdoms-mcp smoke
   tdoms-mcp secure-storage
   tdoms-mcp --help`);
 }
 
+function flagValue(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
 main().catch((error) => {
   console.error(error);
   process.exit(1);

package/src/storage-utils.js

@@ -39,12 +39,14 @@ export async function atomicWriteFile(filePath, data, { mode = 0o600 } = {}) {
 export async function withFileLock(filePath, operation, {
   timeoutMs = 10000,
   staleMs = 30000,
-  retryMs = 20
+  retryMs = 20,
+  privateDirectory = true
 } = {}) {
   const lockPath = `${filePath}.lock`;
   const token = `${process.pid}:${crypto.randomUUID()}`;
   const startedAt = Date.now();
-  await ensurePrivateDirectory(path.dirname(filePath));
+  if (privateDirectory) await ensurePrivateDirectory(path.dirname(filePath));
+  else await fs.mkdir(path.dirname(filePath), { recursive: true });
 
   while (true) {
     try {

package/src/ui-page.js

@@ -68,7 +68,7 @@ export function renderPage() {
     .details-fields { display: grid; gap: 12px; margin-top: 12px; }
     details:not([open]) .details-fields { display: none; }
     .form-actions { display: flex; justify-content: flex-end; gap: 8px; padding-top: 2px; }
-    .button { min-height: 36px; border: 1px solid #1f6d59; border-radius: 6px; padding: 7px 12px; display: inline-flex; align-items: center; justify-content: center; gap: 7px; background: #2f7d67; color: #fff; font-size: 12px; font-weight: 700; white-space: nowrap; }
+    .button { min-height: 36px; border: 1px solid #1f6d59; border-radius: 6px; padding: 7px 12px; display: inline-flex; align-items: center; justify-content: center; gap: 7px; background: #2f7d67; color: #fff; font-size: 12px; font-weight: 700; white-space: nowrap; text-decoration: none; }
     .button:hover { background: #276b58; }
     .button.secondary { background: #fff; border-color: #bdc8d0; color: #283642; }
     .button.secondary:hover { background: #f5f7f8; }
@@ -94,6 +94,12 @@ export function renderPage() {
     .status::before { content: ""; width: 6px; height: 6px; border-radius: 50%; background: currentColor; }
     .clients-toolbar { display: flex; justify-content: space-between; align-items: center; gap: 14px; margin-bottom: 14px; }
     .clients-toolbar-actions { display: flex; align-items: center; justify-content: flex-end; gap: 12px; flex-wrap: wrap; }
+    .segmented { display: inline-flex; border: 1px solid #bdc8d0; border-radius: 6px; overflow: hidden; background: #fff; }
+    .segmented button { min-height: 34px; border: 0; border-right: 1px solid #d5dde3; padding: 6px 10px; background: #fff; color: #53616d; font-size: 11px; font-weight: 700; }
+    .segmented button:last-child { border-right: 0; }
+    .segmented button.active { background: #eaf3f0; color: #215f50; }
+    .path-stack { display: grid; gap: 3px; }
+    .path-label { display: inline-block; width: 38px; color: #52616d; font-family: Inter, ui-sans-serif, system-ui, sans-serif; font-weight: 700; }
     .section-heading { font-size: 15px; font-weight: 750; }
     .environment-label { margin-top: 3px; color: #687582; font-size: 11px; }
     .filter { display: flex; align-items: center; gap: 7px; color: #66737f; font-size: 12px; }
@@ -198,6 +204,11 @@ export function renderPage() {
           <div><div class="section-heading">MCP clients</div><div class="environment-label" id="environment-label">Detecting environment</div></div>
           <div class="clients-toolbar-actions">
             <label class="filter"><input type="checkbox" id="show-all-clients">Show products not detected</label>
+            <div class="segmented" aria-label="Skill installation scope">
+              <button type="button" class="active" data-skill-scope="user">User skill</button>
+              <button type="button" data-skill-scope="workspace">Workspace skill</button>
+            </div>
+            <button class="button secondary" id="install-detected-skills"><img src="/icons/book-open.svg" alt="">Install skills</button>
             <button class="button" id="install-detected"><img src="/icons/plug-zap.svg" alt="">Configure detected</button>
           </div>
         </div>
@@ -217,7 +228,7 @@ export function renderPage() {
   </dialog>
 
   <script>
-    const state = { connections: [], clients: [], pendingAction: null };
+    const state = { connections: [], clients: [], pendingAction: null, skillScope: "user" };
     const form = document.querySelector("#connection-form");
     const connectionList = document.querySelector("#connections-list");
     const clientList = document.querySelector("#clients-list");
@@ -271,18 +282,29 @@ export function renderPage() {
       const clients = state.clients.filter(function (item) { return showAll || item.detected; });
       const detected = state.clients.filter(function (item) { return item.detected; }).length;
       const pending = state.clients.filter(function (item) { return item.detected && item.installable && !item.configured; }).length;
+      const pendingSkills = state.clients.filter(function (item) { return item.detected && item.skill && item.skill.supported && !item.skill[state.skillScope].current; }).length;
       const environment = state.clients[0] && state.clients[0].environment;
       document.querySelector("#environment-label").textContent = environment ? environment.label + " | " + environment.note : "Current environment";
       document.querySelector("#install-detected").disabled = pending === 0;
+      document.querySelector("#install-detected-skills").disabled = pendingSkills === 0;
       document.querySelector("#client-count").textContent = detected + " detected";
       if (!clients.length) {
         clientList.innerHTML = '<div class="empty">No supported MCP clients detected</div>';
         return;
       }
       clientList.innerHTML = clients.map(function (item) {
-        const action = item.configured ? "Update" : "Install";
-        const button = item.installable ? '<button class="button secondary" data-install="' + escapeHtml(item.id) + '"><img src="/icons/plug-zap.svg" alt="">' + action + '</button>' : '';
-        return '<div class="client-row"><div class="row-main"><div class="row-identity"><div class="row-icon"><img src="/icons/terminal.svg" alt=""></div><div><div class="row-name">' + escapeHtml(item.name) + '</div><div class="row-description">' + escapeHtml(item.description) + '</div></div></div><div class="row-actions"><span class="status ' + escapeHtml(item.status) + '">' + escapeHtml(item.status.replace("-", " ")) + '</span>' + button + '</div></div><div class="row-path">' + escapeHtml(item.configPath) + '</div></div>';
+        const mcpAction = item.configured ? "Update MCP" : "Install MCP";
+        const mcpButton = item.installable ? '<button class="button secondary" data-install="' + escapeHtml(item.id) + '"><img src="/icons/plug-zap.svg" alt="">' + mcpAction + '</button>' : '';
+        const skill = item.skill || { supported: false };
+        const scopedSkill = skill.supported ? skill[state.skillScope] : null;
+        const skillAction = scopedSkill && scopedSkill.installed ? "Update skill" : "Install skill";
+        const skillButton = skill.supported && item.detected ? '<button class="button secondary" data-install-skill="' + escapeHtml(item.id) + '" title="' + escapeHtml(skill.guidance) + '"><img src="/icons/book-open.svg" alt="">' + skillAction + '</button>' : '';
+        const skillDownload = skill.downloadable && item.detected ? '<button class="button secondary" data-install-upload-skill="' + escapeHtml(item.id) + '" title="' + escapeHtml(skill.guidance) + '"><img src="/icons/download.svg" alt="">Install skill</button>' : '';
+        const unavailableStatus = !skill.supported && !skill.downloadable && item.detected ? '<span class="status not-detected" title="' + escapeHtml(skill.guidance) + '">skill unavailable</span>' : '';
+        const uploadStatus = skill.downloadable ? '<span class="status detected">upload required</span>' : '';
+        const skillStatus = scopedSkill ? '<span class="status ' + (scopedSkill.current ? 'configured' : 'detected') + '">' + (scopedSkill.current ? 'skill current' : scopedSkill.installedAny ? 'skill update' : 'skill available') + '</span>' : uploadStatus || unavailableStatus;
+        const skillPath = scopedSkill ? scopedSkill.targets.map(function (target) { return '<div><span class="path-label">Skill</span>' + escapeHtml(target.label) + ': ' + escapeHtml(target.path) + '</div>'; }).join('') : '';
+        return '<div class="client-row"><div class="row-main"><div class="row-identity"><div class="row-icon"><img src="/icons/terminal.svg" alt=""></div><div><div class="row-name">' + escapeHtml(item.name) + '</div><div class="row-description">' + escapeHtml(item.description) + '</div></div></div><div class="row-actions"><span class="status ' + escapeHtml(item.status) + '">' + escapeHtml(item.status.replace("-", " ")) + '</span>' + skillStatus + skillButton + skillDownload + mcpButton + '</div></div><div class="row-path path-stack"><div><span class="path-label">MCP</span>' + escapeHtml(item.configPath) + '</div>' + skillPath + '</div></div>';
       }).join("");
     }
 
@@ -375,9 +397,21 @@ export function renderPage() {
 
     clientList.addEventListener("click", function (event) {
       const install = event.target.closest("[data-install]");
-      if (!install) return;
-      const item = state.clients.find(function (entry) { return entry.id === install.dataset.install; });
-      openConfirmation({ title: item.configured ? "Update MCP client" : "Install MCP client", message: "A backup is created before the client configuration changes.", target: item.name, action: async function () { notify("Configuring " + item.name); const result = await request("/api/clients/" + encodeURIComponent(item.id) + "/install", { method: "POST", body: JSON.stringify({ confirm: true }) }); notify(result.restartRequired ? item.name + " configured. Restart the client." : item.name + " configured."); await refresh(); } });
+      const installSkill = event.target.closest("[data-install-skill]");
+      const installUploadSkill = event.target.closest("[data-install-upload-skill]");
+      if (install) {
+        const item = state.clients.find(function (entry) { return entry.id === install.dataset.install; });
+        openConfirmation({ title: item.configured ? "Update MCP client" : "Install MCP client", message: "A backup is created before the client configuration changes.", target: item.name, action: async function () { notify("Configuring " + item.name); const result = await request("/api/clients/" + encodeURIComponent(item.id) + "/install", { method: "POST", body: JSON.stringify({ confirm: true }) }); notify(result.restartRequired ? item.name + " configured. Restart the client." : item.name + " configured."); await refresh(); } });
+      }
+      if (installSkill) {
+        const item = state.clients.find(function (entry) { return entry.id === installSkill.dataset.installSkill; });
+        const scopedSkill = item.skill[state.skillScope];
+        openConfirmation({ title: scopedSkill.installed ? "Update agent skill" : "Install agent skill", message: "The complete TD/OMS workflow skill is installed for every compatible detected agent in this product. Existing skill files are backed up first.", target: item.name + " | " + state.skillScope + " | " + scopedSkill.targets.map(function (target) { return target.label + ": " + target.path; }).join(" | "), action: async function () { notify("Installing skill for " + item.name); const result = await request("/api/clients/" + encodeURIComponent(item.id) + "/install-skill", { method: "POST", body: JSON.stringify({ confirm: true, scope: state.skillScope }) }); notify(result.restartRequired ? item.name + " skill installed. Restart the agent session." : item.name + " skill installed."); await refresh(); } });
+      }
+      if (installUploadSkill) {
+        const item = state.clients.find(function (entry) { return entry.id === installUploadSkill.dataset.installUploadSkill; });
+        openConfirmation({ title: "Install skill in Claude Desktop", message: "Claude Desktop chat requires an account upload. Confirm to download the correctly packaged ZIP, then open Customize > Skills > Create skill > Upload a skill and select it.", target: "tdoms-mcp-routing.zip", action: async function () { const link = document.createElement("a"); link.href = "/api/skill/archive"; link.download = "tdoms-mcp-routing.zip"; document.body.appendChild(link); link.click(); link.remove(); notify("Skill ZIP downloaded. Upload it in Claude Desktop Customize > Skills."); } });
+      }
     });
 
     document.querySelectorAll(".tab").forEach(function (tab) {
@@ -389,10 +423,21 @@ export function renderPage() {
     document.querySelector("#refresh").addEventListener("click", refresh);
     document.querySelector("#clear-form").addEventListener("click", resetForm);
     document.querySelector("#show-all-clients").addEventListener("change", renderClients);
+    document.querySelectorAll("[data-skill-scope]").forEach(function (button) {
+      button.addEventListener("click", function () {
+        state.skillScope = button.dataset.skillScope;
+        document.querySelectorAll("[data-skill-scope]").forEach(function (item) { item.classList.toggle("active", item === button); });
+        renderClients();
+      });
+    });
     document.querySelector("#install-detected").addEventListener("click", function () {
       const pending = state.clients.filter(function (item) { return item.detected && item.installable && !item.configured; });
       openConfirmation({ title: "Configure detected agents", message: "This adds TD/OMS only to detected agents that are not configured yet. Every existing file is backed up first.", target: pending.map(function (item) { return item.name; }).join(", "), action: async function () { notify("Configuring detected agents"); const result = await request("/api/clients/install-detected", { method: "POST", body: JSON.stringify({ confirm: true }) }); notify(result.configured + " agents configured" + (result.failed ? ", " + result.failed + " failed" : ""), Boolean(result.failed)); await refresh(); } });
     });
+    document.querySelector("#install-detected-skills").addEventListener("click", function () {
+      const pending = state.clients.filter(function (item) { return item.detected && item.skill && item.skill.supported && !item.skill[state.skillScope].current; });
+      openConfirmation({ title: "Install detected agent skills", message: "This installs or updates the bundled TD/OMS workflow skill for the selected scope. Existing skill folders are backed up first.", target: state.skillScope + " | " + pending.map(function (item) { return item.name; }).join(", "), action: async function () { notify("Installing detected agent skills"); const result = await request("/api/clients/install-detected-skills", { method: "POST", body: JSON.stringify({ confirm: true, scope: state.skillScope }) }); notify(result.installed + " skills installed" + (result.failed ? ", " + result.failed + " failed" : ""), Boolean(result.failed)); await refresh(); } });
+    });
     document.querySelector("#dialog-close").addEventListener("click", closeDialog);
     document.querySelector("#dialog-cancel").addEventListener("click", closeDialog);
     document.querySelector("#dialog-confirm").addEventListener("click", async function () {

package/src/web-app.js

@@ -40,6 +40,20 @@ export function createWebApp({ store = new ConnectionStore(), clientManager = ne
     }
   });
 
+  app.get("/api/skill/archive", async (_req, res, next) => {
+    try {
+      const archive = await clientManager.createSkillArchive();
+      res.set({
+        "content-type": "application/zip",
+        "content-disposition": "attachment; filename=tdoms-mcp-routing.zip",
+        "content-length": archive.length
+      });
+      res.send(archive);
+    } catch (error) {
+      next(error);
+    }
+  });
+
   app.post("/api/clients/:id/install", async (req, res, next) => {
     try {
       const result = await clientManager.installClient(req.params.id, { confirm: req.body?.confirm === true });
@@ -58,6 +72,30 @@ export function createWebApp({ store = new ConnectionStore(), clientManager = ne
     }
   });
 
+  app.post("/api/clients/:id/install-skill", async (req, res, next) => {
+    try {
+      const result = await clientManager.installSkill(req.params.id, {
+        confirm: req.body?.confirm === true,
+        scope: req.body?.scope || "user"
+      });
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.post("/api/clients/install-detected-skills", async (req, res, next) => {
+    try {
+      const result = await clientManager.installDetectedSkills({
+        confirm: req.body?.confirm === true,
+        scope: req.body?.scope || "user"
+      });
+      res.status(result.ok ? 200 : 207).json(result);
+    } catch (error) {
+      next(error);
+    }
+  });
+
   app.post("/api/connections", async (req, res, next) => {
     try {
       const connection = await store.upsertConnection(req.body);