Add C# and shell execution playbooks with icons, aliases, and integration tests:

- Introduced `code-run-csharp` and `code-run-shell` skills with detailed playbooks for computation and shell command execution.
- Added new icons to `AppIcon.razor` and updated associated skill metadata.
- Enhanced skill alias validation and tests to support `#` suffix usage.
- Updated UI and CSS for better hover and edit interactions in endpoint rows.
- Integrated unit tests for skill catalog exposure and alias matching.

Author: NikolayPianikov

src/AI.Contracts/Skills/SkillIcons.cs

@@ -39,6 +39,7 @@ public static bool IsPath(string icon) =>
         "git-rebase", "git-rebase-auto", "git-merge-auto",
         "code-plan", "code-explain", "code-refactor", "code-tests-add", "code-build-fix",
         "code-review", "code-performance-optimize", "code-dependencies-update", "code-security-review", "code-docs-update",
+        "code-run-csharp", "code-run-shell",
         "devops-ci-create", "devops-ci-fix", "devops-container-create", "devops-compose-configure",
         "devops-config-review", "devops-release-prepare", "devops-deploy", "devops-rollback",
         "devops-incident-diagnose", "devops-observability-configure", "devops-infrastructure-change", "devops-backup-verify",

src/AI.Server/Application/Skills/SkillMarkdown.cs

@@ -23,9 +23,9 @@ public static SkillDefinition Parse(string content, string source, Guid? project
             throw new ArgumentException("Skill id must be lowercase letters, digits and hyphens, starting with a letter.");
         var aliases = Field("aliases") is { } aliasesText
             ? JsonSerializer.Deserialize<string[]>(aliasesText) ?? [] : [];
-        if (aliases.Length > 8 || aliases.Any(alias => !IsCommand(alias) || alias == id)
+        if (aliases.Length > 8 || aliases.Any(alias => !IsAlias(alias) || alias == id)
             || aliases.Distinct(StringComparer.Ordinal).Count() != aliases.Length)
-            throw new ArgumentException("Skill aliases are up to 8 distinct commands spelled like an id and different from it.");
+            throw new ArgumentException("Skill aliases are up to 8 distinct commands spelled like an id, optionally ending in #, and different from it.");
         var icon = Field("icon");
         if (icon is not null && !SkillIcons.IsValid(icon))
             throw new ArgumentException($"Skill icon must be one of: {string.Join(", ", SkillIcons.Names)}; "
@@ -77,6 +77,9 @@ public static string Body(string content)
         return string.Join('\n', lines.Skip(end + 1)).Trim();
     }
 
+    private static bool IsAlias(string text) =>
+        IsCommand(text) || text.Length is >= 2 and <= 64 && text[^1] == '#' && IsCommand(text[..^1]);
+
     private static bool IsCommand(string text) =>
         text.Length is >= 1 and <= 64 && text[0] is >= 'a' and <= 'z' && text[^1] != '-'
         && text.All(character => character is >= 'a' and <= 'z' or >= '0' and <= '9' or '-');

src/AI.Server/Skills/BuiltIn/code-run-csharp/SKILL.md

@@ -0,0 +1,78 @@
+---
+id: code-run-csharp
+name: Code run csharp
+aliases: ["c#","cs","csharp","cs-run"]
+icon: code-run-csharp
+kind: playbook
+description: Solve algorithmic, computational and complex automation tasks with C# through cs_run when available; may change files or external data only within the user's authorized scope, with risk, duration and encoding checks.
+parameters: {"type":"object","properties":{"task":{"type":"string","description":"The calculation or automation goal"},"paths":{"type":"array","items":{"type":"string"},"maxItems":200,"description":"Input or output paths provided by the user"}},"additionalProperties":false}
+tools: ["tool_search","cs_run","process_run","read_text_file","get_file_info","list_directory","write_file","create_directory","ask_user"]
+---
+
+The user's instructions take precedence. Follow repository instructions and use ordinary
+permission-checked tools; this playbook grants no access. Report in the user's language.
+Use C# for algorithms, graph search, optimization, exact arithmetic, simulations, hypothesis
+checks and complex data transformations when a script improves reliability. Prefer a dedicated
+tool for simple operations. A normal C# development request does not require executing a script.
+
+1. Establish the goal, input, output and authorized changes from the message and parameters.
+   Check available tools; discover `cs_run` through `tool_search` when necessary. It is an optional
+   external tool and may not be installed or connected. Source files or a .NET runtime do not prove
+   availability. Read the actual tool description and schema, including its host OS and limits.
+   If unavailable, explain briefly and continue with a suitable available tool or runtime through
+   `process_run`; do not install or connect a server automatically. Report a concrete blocker if
+   no available mechanism can complete the task.
+2. Select an algorithm and estimate time, memory and output size. Pass data through `arguments`
+   (`Args`) or `globals` (`Globals`, a read-only dictionary of `JsonElement`), rather than injecting
+   user text into source code. Use top-level C# statements and optional `using` directives; no
+   `Program` or `Main` is needed. A final expression without a semicolon is the return value.
+   Each call is independent. Use `BigInteger` for exact large integers, `decimal` when exact decimal
+   arithmetic is needed, explicit tolerances for numerical methods and a seed for reproducible
+   simulations. Additional `imports` are namespaces; `references` are resolvable assembly names or
+   DLL paths, not NuGet package names. Never assume automatic package installation.
+3. Assess real risks before execution: deletion, overwrite, moves, database/network mutations,
+   resource exhaustion and side effects of invoked programs. `cs_run` runs in the server process,
+   not a sandbox; its working directory does not restrict access. Client files may not exist on
+   the server. Resolve and verify full source/destination paths, empty inputs, existing outputs,
+   symlinks/junctions and source/destination overlap. Before recursive deletion or moves verify
+   the final target is inside the intended authorized area, not an accidental root, home or whole
+   working tree. Preview targets or use a dry run where supported. Preserve important originals
+   or write and verify a separate output before replacement. For read-only calculations, check
+   resource bounds without introducing a blanket approval step. Existing authorization stands;
+   prepare concrete targets and ask only for missing authorization for irreversible actions
+   outside the request. Declined stops that action; unresolved approval never authorizes it.
+4. Plan duration before starting. Work can take hours and exceed both tool and client timeouts.
+   The known cs_run contract accepts `timeoutMs` from 1 to 120000, default 120000; the current
+   schema wins. Never pass a value above its maximum. For long work, use bounded batches with
+   persisted checkpoints and resumable progress, or a genuinely available managed long-running
+   job/session with status, logs, cancellation and a final result. Moving to `process_run` alone
+   does not remove its timeout. If no suitable mechanism exists, explain the limit and prepare a
+   reproducible script without claiming it ran. Do not leave background Tasks in the server or
+   bypass timeouts. Bound loops with a local deadline (for example `Stopwatch`) and pass local
+   cancellation tokens to cooperative I/O. Arbitrary C# is not guaranteed to stop on timeout;
+   use a controlled separate process if hard termination or isolation is required. Check actual
+   state before retrying timed-out work, especially mutations.
+5. Preserve encoding. JSON code, Args and Globals are Unicode strings; ordinary Console output
+   is captured as text. Changing the server's global Console encoding is unnecessary and does not
+   repair incorrectly decoded input. For byte streams and files choose an explicit encoding;
+   default new text artifacts to UTF-8 without BOM unless the consumer requires another format.
+   Respect existing BOM, encoding and line endings; missing BOM does not establish UTF-8. Use
+   strict decoding when corruption matters rather than silently persisting replacement characters.
+   For child programs separately agree stdin/stdout/stderr encodings before launch. Distinguish
+   encoding from culture; use explicit numeric/date formats or InvariantCulture for machine data.
+   Check a short non-ASCII round trip when its preservation is important. Avoid logging secrets.
+6. Run the self-contained script with a verified server-side absolute `workingDirectory` when
+   needed. In the known implementation, a missing directory can leave the previous directory
+   unchanged, so verify existence. Return compact structured data with `JsonSerializer.Serialize`:
+   `returnValue` and `variables` are textual renderings, not automatically JSON objects. Known
+   limits are 262144 code characters, 32768 characters per output stream, 4096 per value and 64
+   returned variables. Save large authorized results to a file, verify it and ensure the user can
+   access it if the server is remote. Avoid modifying server global state, Environment.Exit and
+   unjoined background work. Run operations sharing process state sequentially.
+7. Inspect `success`, `diagnostics`, `error`, `timedOut`, `truncated`, stdout and stderr. Fix
+   compilation problems from diagnostics. Before retrying runtime failures inspect partial side
+   effects: restoration of working directory/environment/console does not roll back files or
+   remote data. Validate a known small case, invariant, independent calculation or error bound;
+   for batches verify the full expected range was completed. Do not accept a truncated answer as
+   complete. The final answer contains the computed result, verification and material accuracy or
+   completion limits; for large artifacts include their accessible location and a useful summary.

src/AI.Server/Skills/BuiltIn/code-run-shell/SKILL.md

@@ -0,0 +1,105 @@
+---
+id: code-run-shell
+name: Code run shell
+aliases: ["shell","cli","powershell","pwsh","process-run"]
+icon: code-run-shell
+kind: playbook
+description: Run programs and shell commands through process_run on Windows, Linux or macOS, including PowerShell; may change files or external data only within the user's authorized scope, with risk, duration and encoding checks.
+parameters: {"type":"object","properties":{"task":{"type":"string","description":"The command or automation goal"},"shell":{"type":"string","description":"Shell explicitly chosen by the user"},"workingDirectory":{"type":"string","description":"Working directory provided by the user"}},"additionalProperties":false}
+tools: ["tool_search","process_run","read_text_file","get_file_info","list_directory","write_file","create_directory","ask_user"]
+---
+
+The user's instructions take precedence. Follow repository instructions and use ordinary
+permission-checked tools; this playbook grants no access. Report in the user's language.
+Prefer a direct executable and argv array. Use a shell for its built-ins, pipelines, redirection
+or scripts, and a dedicated tool when it better serves the task.
+
+1. Establish the goal, inputs and authorized side effects. Check `process_run` availability,
+   discovering it through `tool_search` if needed, and read its current description/schema.
+   If unavailable, briefly explain and use another available executor; do not install/connect
+   tools automatically. Identify the server OS, not the client's OS, and verify executable paths,
+   shell availability/version and working directory with permitted read-only checks.
+2. Use `executable`, string-array `arguments`, verified `workingDirectory` and supported
+   `timeoutMs`. In the known contract, a bare executable name is resolved through PATH even with
+   a working directory; use an absolute path or `./name` for a file in that directory. Each array
+   element is one argv entry: do not wrap a path in extra quotes just because it contains spaces.
+   There is no implicit shell, glob or variable expansion; `*`, `~`, `$VAR`, `%VAR%`, pipes and
+   redirects are literal arguments unless a shell explicitly parses them. Stdin is closed at
+   launch: use noninteractive modes and supported input files, not interactive prompts. Known
+   parameters do not include stdin, environment, encoding, background mode or session polling;
+   do not invent them. The actual schema wins.
+3. Choose the shell explicitly when required:
+   - Windows PowerShell 7: `pwsh` with `-NoLogo`, `-NoProfile`, `-NonInteractive`, `-Command`,
+     then one string of PowerShell code; or use `-File` for a verified .ps1 file.
+   - Windows PowerShell 5.1: `powershell.exe` with the same switches, but use syntax and encoding
+     supported by that version. PowerShell 7 is not guaranteed to be installed.
+   - Windows cmd: `cmd.exe` with `/d`, `/s`, `/c`, then cmd code for cmd built-ins or .cmd/.bat
+     files. Respect cmd-specific quoting and percent expansion.
+   - Linux/macOS POSIX shell: verified `/bin/sh` with `-c`, then POSIX code; avoid Bash extensions.
+     For Bash-specific code use verified `bash` with `--noprofile`, `--norc`, `-c`, then Bash code.
+     Do not assume a particular Bash version, especially on macOS. Use zsh only when appropriate
+     and verified. `pwsh` also works on Linux/macOS when actually installed.
+   Respect host path syntax, case sensitivity, executable extensions and line endings. Avoid
+   interactive profiles unless required. On Windows keep recursive filesystem operations in one
+   shell, using PowerShell -LiteralPath where applicable; do not enumerate there and delete via cmd.
+4. For complex PowerShell use a .ps1 with `param(...)`, `-File` and values as separate arguments.
+   Example argv: `["-NoLogo","-NoProfile","-NonInteractive","-File","C:\\work\\job.ps1",
+   "-InputPath","C:\\work\\данные.json"]`; first verify those actual paths or use the host's paths.
+   `-Command` receives code to be parsed: an argv array does not protect interpolated data inside
+   that code. For POSIX shell pass data as positional arguments: `sh -c '<code using "$1">'
+   task '<value>'`. Use `--` for values beginning with '-' only when the program supports it.
+   JSON escaping is not shell escaping. PowerShell -EncodedCommand is Base64 of UTF-16LE code,
+   not protection against injection or an output-encoding setting. Do not automatically bypass
+   ExecutionPolicy. For scripts requiring stop-on-error set `$ErrorActionPreference = 'Stop'`;
+   check `$LASTEXITCODE` immediately after important native programs and propagate an appropriate
+   `exit` code. Nonterminating PowerShell errors and native program failures need separate checks.
+5. Assess deletion, overwrite, moves, database/network changes and disk exhaustion before launch.
+   The working directory is not a sandbox. Verify full targets, empty inputs, source/destination
+   overlap, existing outputs and symlinks/junctions. Before recursive deletion/moves confirm the
+   final path is within the intended authorized area, not an accidental root, home or entire
+   working tree. Preview targets or use dry-run/-WhatIf where supported; preserve important
+   originals or write and verify a new output before replacement. Inspect the entire command:
+   redirection can truncate a file before the program succeeds. Do not add blanket approval for
+   ordinary reads or already authorized changes. Prepare concrete targets and ask only for missing
+   authorization for irreversible actions outside the request. Declined stops that action;
+   unresolved approval does not authorize it. Process termination does not undo partial changes.
+6. Estimate duration: builds, data processing and automation may take hours. Check tool/client
+   limits and whether a genuine managed long-running execution mechanism exists. The known
+   `timeoutMs` range is 1–120000, default 120000; timeout/cancellation terminates the process tree.
+   Do not exceed the schema. If insufficient, use safely separable batches/stages with checkpoints,
+   or an available managed job/session/queue with identifier, status, logs, cancellation and final
+   result. Do not split atomic operations in ways that damage integrity. Change a timeout setting
+   only when actually supported and authorized. If no suitable mechanism exists, explain the
+   limit and prepare a reproducible script without claiming completion. Do not bypass limits with
+   nohup, &, detached processes or Start-Process: children may be terminated and launch does not
+   prove completion. When a supported workflow needs Start-Process on Windows, use -WindowStyle
+   Hidden unless a visible interactive window is explicitly needed. After timeout inspect actual
+   status, partial artifacts and logs before retrying safely resumable work.
+7. Agree encodings for input files, stdout/stderr and artifacts. JSON argv is Unicode, but child
+   byte streams and files may use UTF-8, OEM/ANSI or UTF-16. Prefer explicit UTF-8 modes when the
+   program supports them; agree with the tool's decoder rather than assuming UTF-8. If the decoder
+   cannot be configured, capture raw output to a file using byte-preserving means and read it
+   with a known encoding through an available file tool or controlled decoder. Do not repair text
+   after replacement characters have lost information. Check a short Cyrillic/non-ASCII example
+   when important. Preserve existing encoding, BOM and line endings; default new text to UTF-8
+   without BOM unless the consumer needs another format. Do not expose secrets in argv or logs.
+   - PowerShell 7 usually writes UTF-8 without BOM; Windows PowerShell 5.1 defaults vary by cmdlet,
+     and Out-File/> commonly write UTF-16LE. Specify -Encoding with a value supported by the version.
+     For .ps1 with non-ASCII under 5.1 use UTF-8 with BOM or another correctly readable encoding.
+     Use .NET file APIs when an exact byte format is needed.
+   - `[Console]::OutputEncoding` governs console output; `$OutputEncoding` governs text sent to
+     native programs through pipelines. Set them locally only as needed and agree with decoding.
+     Neither `chcp 65001` nor a PowerShell encoding assignment forces every native program to
+     emit UTF-8. Avoid `cmd /u` unless UTF-16 output from cmd built-ins matches the decoder.
+   - On Linux/macOS verify an available UTF-8 locale rather than assuming C.UTF-8 exists. The known
+     runner restricts inherited environment variables; do not assume LANG or arbitrary credentials
+     survive. Use a supported program/wrapper mechanism for required environment, without changing
+     the server globally. Locale also affects dates, decimal separators and sorting; use explicit
+     machine formats when needed.
+8. Inspect `exitCode`, `error`, `timedOut`, `truncated`, stdout and stderr. A nonzero code depends on
+   the program's contract (for example a search with no matches); absence of stderr is not proof of
+   success. Known capture is limited to 32768 characters per stream; save complete authorized logs
+   through program options or an explicit shell redirect with a correct encoding. Verify the final
+   artifacts and intended postconditions. Before retrying failures inspect partial side effects.
+   The final answer contains the requested command result or accessible artifacts, actual checks
+   and any unresolved duration, encoding or completeness limits. A running job is not a passed run.

src/AI.Server/Skills/BuiltIn/skill-create/SKILL.md

@@ -26,7 +26,7 @@ Skill conventions:
   activity, timer, alarm, calendar-check, repeat, history, palette, brush, pen-tool, crop, camera,
   video, microphone, headphones, music, map, git-rebase, git-rebase-auto, git-merge-auto, code-plan,
   code-explain, code-refactor, code-tests-add, code-build-fix, code-review, code-performance-optimize,
-  code-dependencies-update, code-security-review, code-docs-update, devops-ci-create, devops-ci-fix,
+  code-dependencies-update, code-security-review, code-docs-update, code-run-csharp, code-run-shell, devops-ci-create, devops-ci-fix,
   devops-container-create, devops-compose-configure, devops-config-review, devops-release-prepare,
   devops-deploy, devops-rollback, devops-incident-diagnose, devops-observability-configure,
   devops-infrastructure-change, devops-backup-verify, qa-plan, qa-acceptance-define, qa-cases-create,