Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
feat(skills): the class, not the instance — every "routine / automation / workflow" request, the skill lifecycle by voice, and a CLI the brain can see
Harald40cdc44458b6
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 627534ad1c..8ad8666869 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -114,6 +114,16 @@ versioning per [SemVer](https://semver.org/).- The UI's skill-creator dialog and `jarvis skills draft` see the same livetool inventory now, so their drafts name real connectors too; `draft` gained`--trigger`, `--schedule`, `--language`.+- **Skills by voice, the rest of the lifecycle:** "welche Skills habe ich",+ "aktiviere den Skill Morgenroutine", "deaktiviere den Spotify-Skill", "lösch <!-- i18n-allow: quoted voice requests -->+ den Skill Abendroutine" are first-class app commands now (`skills-list` over+ a new lean `GET /api/skills/brief`, `skill-enable`, `skill-disable`,+ `skill-delete` — the last one asks first). Enabling the draft the assistant+ just wrote is one sentence away, and it happens only when you ask.+- **The assistant knows its own CLI.** The `cli_jarvisctl` tool now carries the+ complete `jarvisctl` command tree with argument hints, parity-tested against+ the real CLI — no more turns spent reading `--help` before a `skills`,+ `workflows`, `modes`, `tasks`, `wiki` or `board` command.- **Two plain wallpapers: black and white.** The Wallpaper section now openswith four pictures that ship inside the app — the night original, itsdaylight twin, pure black and pure white — under two chips, "Original" and@@ -137,6 +147,10 @@ versioning per [SemVer](https://semver.org/).keeps force-spawn and the evidence gate out of such a turn. The`skill-creator` builtin's own card is a short "call create-skill once" now;Anthropic's long guide moved to `references/anthropic-skill-creator.md`.+ The same rule now covers every word the product uses for "a skill" —+ routine ("Morgenroutine"), automation, workflow, Ablauf — and lifecycle+ requests: "deaktiviere den YouTube-Music-Skill" no longer RUNS the music+ skill.- The key-format hint no longer calls an `AIza` key a "Google AI Studio key".The same shape is issued for Google Cloud, so the label is endpoint-neutraldiff --git a/docs/BUGS.md b/docs/BUGS.mdindex 66819f98d0..a86514e183 100644--- a/docs/BUGS.md+++ b/docs/BUGS.md@@ -10276,6 +10276,23 @@ the prompt, `author()` never commits a skeleton),`tests/unit/cli_ctl/test_commands_wave23.py`,`tests/fixtures/skill_routing/golden.yaml` (forensic positive).+**Generalised the same day** (maintainer: "why not automatically — this+applies to many other things"). The class, not the instance: (1) the meta+resolver covers every spoken synonym of "a skill" (routine, Morgenroutine,+Automatisierung, workflow, Ablauf; ES rutina/automatización/flujo) and a+second kind, *lifecycle* — "deaktiviere / lösch / zeig den Skill X" lets no <!-- i18n-allow: quoted voice requests -->+brand skill capture, so "deaktiviere den YouTube-Music-Skill" no longer plays+music; (2) the skill lifecycle is in the Command Registry (`skills-list` over+the new lean `GET /api/skills/brief`, `skill-enable`, `skill-disable`,+`skill-delete`) — first-class tools instead of CLI discovery; (3) the+`cli_jarvisctl` tool description carries the whole command tree+(`jarvis/cli_ctl/command_index.py`, parity-tested against the live Typer+app), which closes the "`--help` rounds" class for every CLI group, not just+skills. Guards: `tests/unit/cli_ctl/test_command_index_parity.py`,+`tests/unit/clis/test_tool.py`, `tests/unit/commands/test_registry_parity.py`,+the lifecycle cases in `tests/unit/skills/test_authoring_request.py` and+`tests/unit/brain/test_skill_authoring_turn.py`.+## BUG-148: a Vertex Live readback is spoken twice, and three grounded answers in a row are never heard — the stale-generation guard was stamped before the speaker drained, and Vertex Live had no realtime-scoped emergency voice (HIGH, FIXED 2026-08-18)**Symptom.** Realtime voice session `28cf8436` (2026-08-18 18:39, Vertex Live,diff --git a/docs/adr/0011-router-pure-dispatcher.md b/docs/adr/0011-router-pure-dispatcher.mdindex af4c646f65..308339ce37 100644--- a/docs/adr/0011-router-pure-dispatcher.md+++ b/docs/adr/0011-router-pure-dispatcher.md@@ -1157,6 +1157,39 @@ that service adds a caller, not a place to forget.Direct gated action, never a spawn, never in a worker tool set (AP-5/AP-14).+#### Same day, generalised — the class, not the instance++The first cut protected only the literal word "skill" and only creation. The+maintainer's objection ("why not automatically — this applies to many other+things") is right, and the two failure classes are:++1. *A brand mentioned inside a request ABOUT an internal artifact captures the+ turn.* The resolver now covers every noun this product uses for "a skill"+ in speech — routine (incl. compounds: "Morgenroutine"), automation /+ "Automatisierung", workflow, "Ablauf", "Fähigkeit", ES "rutina" /+ "automatización" / "flujo" — and a second kind, **lifecycle**: "deaktiviere+ / lösch / zeig / disable / delete / list … den Skill X" lets nobody+ capture (veto `skill_lifecycle_request`), so the brand skill named inside+ never RUNS instead of being switched off.+2. *The brain has no first-class tool and burns rounds on `--help`.* Two+ closures: (a) the skill lifecycle is in the Command Registry —+ `skills-list` (new lean `GET /api/skills/brief`), `skill-enable`,+ `skill-disable`, `skill-delete` (dangerous, echo-confirmed) — flat+ `app-command` tools the model sees by name; (b) the `cli_jarvisctl` tool's+ description carries the WHOLE command tree+ (`jarvis/cli_ctl/command_index.py`, static, parity-tested against the live+ Typer app) with argument hints, so workflows, modes, tasks, wiki, board,+ contacts, missions … are all one direct call away — the general fix for the+ `--help`-round class, not a per-feature patch.++Regression guards for the generalisation: `tests/unit/skills/test_authoring_request.py`+(routine / automation / workflow positives, lifecycle kind, hard negatives such+as "schalt das Licht aus" and "starte die Morgenroutine"),+`tests/unit/brain/test_skill_authoring_turn.py` (disable request not captured;+automation request → skill-creator), `tests/unit/commands/test_registry_parity.py`+(new entries exist in OpenAPI), `tests/unit/cli_ctl/test_command_index_parity.py`,+`tests/unit/clis/test_tool.py` (jarvisctl description carries the index).+### Regression guards- `tests/unit/skills/test_authoring_request.py` (the live transcript, hits anddiff --git a/docs/commands-reference.md b/docs/commands-reference.mdindex e79d0505f0..507750a607 100644--- a/docs/commands-reference.md+++ b/docs/commands-reference.md@@ -16,7 +16,7 @@ Commands marked **requires confirmation** never run on a bare voice request —Switch the ACTIVE main brain (LLM) provider, e.g. from openai to claude-api. Reversible; validated against the provider catalog and stored credentials.- **Endpoint:** `POST /api/brain/switch`-- **Arguments:** `provider` (one of: claude-api, gemini, grok, local-openai, nvidia, ollama, openai, openrouter; required); `persist` (boolean; optional)+- **Arguments:** `provider` (one of: claude-api, gemini, grok, local-openai, nvidia, ollama, openai, openrouter, vertex; required); `persist` (boolean; optional)- **Requires confirmation:** no- **Desktop UI section:** `apikeys`- **Voice example (EN):** "switch the brain provider to claude"@@ -26,7 +26,7 @@ Switch the ACTIVE main brain (LLM) provider, e.g. from openai to claude-api. RevSwitch the active text-to-speech provider (live, no restart).- **Endpoint:** `POST /api/tts/switch`-- **Arguments:** `provider` (one of: cartesia, elevenlabs, gemini-flash-tts, grok-voice, inworld, openrouter-tts, piper-local; required); `persist` (boolean; optional)+- **Arguments:** `provider` (one of: cartesia, elevenlabs, gemini-flash-tts, grok-voice, inworld, openrouter-tts, piper-local, vertex-tts; required); `persist` (boolean; optional)- **Requires confirmation:** no- **Desktop UI section:** `apikeys`- **Voice example (EN):** "switch the voice to elevenlabs"@@ -36,7 +36,7 @@ Switch the active text-to-speech provider (live, no restart).Switch the speech-to-text provider. Takes effect on the next voice-pipeline start (restart required).- **Endpoint:** `POST /api/stt/switch`-- **Arguments:** `provider` (one of: faster-whisper, groq-api, nemotron-local, openai-api, openrouter-stt; required); `persist` (boolean; optional)+- **Arguments:** `provider` (one of: faster-whisper, gemini-api, groq-api, nemotron-local, openai-api, openrouter-stt, vertex-stt; required); `persist` (boolean; optional)- **Requires confirmation:** no- **Desktop UI section:** `apikeys`- **Voice example (EN):** "switch speech recognition to deepgram"@@ -46,7 +46,7 @@ Switch the speech-to-text provider. Takes effect on the next voice-pipeline starSwitch which realtime voice engine (speech-to-speech) is active, including subscription- and API-backed providers. Experimental transports require explicit acknowledgement.- **Endpoint:** `POST /api/realtime/switch`-- **Arguments:** `provider` (one of: gemini-live, local-realtime, openai-realtime; required); `persist` (boolean; optional); `accept_experimental` (boolean; optional)+- **Arguments:** `provider` (one of: gemini-live, local-realtime, openai-realtime, vertex-live; required); `persist` (boolean; optional); `accept_experimental` (boolean; optional)- **Requires confirmation:** no- **Desktop UI section:** `apikeys`- **Voice example (EN):** "switch the realtime model to gemini"@@ -66,7 +66,7 @@ Select the Ollama brain and speech model for the managed local realtime server,Switch the dedicated Computer-Use planner provider (screen control), decoupled from the main brain.- **Endpoint:** `POST /api/computer-use/switch`-- **Arguments:** `provider` (one of: antigravity, claude-api, claude-cli, codex, gemini, grok, local-openai, nvidia, ollama, openai, openrouter; required); `persist` (boolean; optional)+- **Arguments:** `provider` (one of: antigravity, claude-api, claude-cli, codex, gemini, grok, local-openai, nvidia, ollama, openai, openrouter, vertex; required); `persist` (boolean; optional)- **Requires confirmation:** no- **Desktop UI section:** `apikeys`- **Voice example (EN):** "switch the computer use provider to gemini"@@ -76,7 +76,7 @@ Switch the dedicated Computer-Use planner provider (screen control), decoupled fSwitch the provider used for new missions (e.g. codex to openai). The next mission uses the new provider.- **Endpoint:** `POST /api/jarvis-agent/switch`-- **Arguments:** `provider` (one of: antigravity, claude-api, claude-cli, codex, gemini, grok, local-openai, nvidia, ollama, openai, openrouter; required); `persist` (boolean; optional)+- **Arguments:** `provider` (one of: antigravity, claude-api, claude-cli, codex, gemini, grok, local-openai, nvidia, ollama, openai, openrouter, vertex; required); `persist` (boolean; optional)- **Requires confirmation:** no- **Desktop UI section:** `agents`- **Voice example (EN):** "switch the agent provider to openai"@@ -96,7 +96,7 @@ List all configured providers and which ones are active.Test connectivity and authentication for one provider.- **Endpoint:** `POST /api/providers/{provider_id}/test`-- **Arguments:** `provider_id` (one of: antigravity, cartesia, claude-api, claude-cli, codex, elevenlabs, faster-whisper, gemini, gemini-flash-tts, gemini-live, gemini-polish, grok, grok-voice, groq-api, groq-polish, inworld, local-openai, local-realtime, nemotron-local, nvidia, ollama, ollama-polish, openai, openai-api, openai-polish, openai-realtime, openrouter, openrouter-polish, openrouter-stt, openrouter-tts, piper-local; required)+- **Arguments:** `provider_id` (one of: antigravity, cartesia, claude-api, claude-cli, codex, elevenlabs, faster-whisper, gemini, gemini-api, gemini-flash-tts, gemini-live, gemini-polish, grok, grok-voice, groq-api, groq-polish, inworld, local-openai, local-realtime, nemotron-local, nvidia, ollama, ollama-polish, openai, openai-api, openai-polish, openai-realtime, openrouter, openrouter-polish, openrouter-stt, openrouter-tts, piper-local, vertex, vertex-live, vertex-stt, vertex-tts; required)- **Requires confirmation:** no- **Desktop UI section:** `apikeys`- **Voice example (EN):** "test the openai provider"@@ -331,6 +331,46 @@ Cancel a running or scheduled task by id.- **Desktop UI section:** `tasks`- **Voice example (EN):** "cancel the task"+## `skills-list` — List installed skills++List the installed skills with their state (active, draft, disabled) and what starts each one. Use this when the user asks which skills they have or which are drafts / switched off.++- **Endpoint:** `GET /api/skills/brief`+- **Arguments:** none+- **Requires confirmation:** no+- **Desktop UI section:** `skills`+- **Voice example (EN):** "which skills do i have"++## `skill-enable` — Enable a skill++Switch an installed skill ON by name — this is how a draft the assistant just wrote (create-skill) or a disabled skill starts firing on its trigger phrase and schedule. Use the exact skill name; list the skills first when unsure.++- **Endpoint:** `POST /api/skills/{name}/enable`+- **Arguments:** `name` (string; required)+- **Requires confirmation:** no+- **Desktop UI section:** `skills`+- **Voice example (EN):** "enable the skill"++## `skill-disable` — Disable a skill++Switch an installed skill OFF by name — it stops firing on its trigger phrase and schedule but stays installed. Use the exact skill name; list the skills first when unsure.++- **Endpoint:** `POST /api/skills/{name}/disable`+- **Arguments:** `name` (string; required)+- **Requires confirmation:** no+- **Desktop UI section:** `skills`+- **Voice example (EN):** "disable the skill"++## `skill-delete` — Delete a skill++Delete an installed user skill by name — removes its folder for good (built-in skills cannot be deleted; disable them instead).++- **Endpoint:** `DELETE /api/skills/{name}`+- **Arguments:** `name` (string; required)+- **Requires confirmation:** yes+- **Desktop UI section:** `skills`+- **Voice example (EN):** "delete the skill"+## `agentic-ide-status` — Agentic IDE statusReport the open Agentic-IDE workspace: which folder, which coding agents run in which named terminals, and whether the focused coding mode is on.diff --git a/jarvis/brain/manager.py b/jarvis/brain/manager.pyindex cce45493bd..457397d2fd 100644--- a/jarvis/brain/manager.py+++ b/jarvis/brain/manager.py@@ -4980,10 +4980,11 @@ class BrainManager:# A skill AUTHORING request names calendar / mail / music only as the# content of the skill to be written; the capability that serves the# turn is the create-skill tool, not those domains' connectors.- if getattr(self, "_skill_authoring_turn", False):+ if getattr(self, "_skill_meta_turn", ""):log.info(- "Evidence gate stood down: skill authoring request — the "- "create-skill tool is the capability"+ "Evidence gate stood down: skill %s request — the skill tools "+ "are the capability",+ self._skill_meta_turn,)return EvidenceVerdict(kind="pass")@@ -5171,12 +5172,15 @@ class BrainManager:_skill_turn_content_fallback: str = ""_skill_turn_source_fallback: str = "match"_skill_injected_inline_fallback: bool = False- # Skill AUTHORING turn (2026-08-18): the user asked to create a NEW skill- # (``jarvis.skills.authoring_request``). Set by ``_match_skill_for_turn``- # on every probe; while True the force-spawn guard and the evidence gate- # stand down — the create-skill router tool is the capability that owns- # such a turn, whether or not the skill-creator builtin captured it.- _skill_authoring_turn: bool = False+ # Skill META turn (2026-08-18): the user talks ABOUT a skill — asks for a+ # new one ("authoring": skill / routine / automation / workflow …) or wants+ # one switched off, deleted, listed ("lifecycle"). Set by+ # ``_match_skill_for_turn`` on every probe (``""`` otherwise); while set,+ # the force-spawn guard and the evidence gate stand down and no domain+ # skill may capture — the create-skill router tool / the skill+ # app-commands are the capability that owns such a turn, whether or not+ # the skill-creator builtin captured it. See jarvis/skills/authoring_request.py.+ _skill_meta_turn: str = ""# AD-S6: warn exactly once per manager lifetime when the AVAILABLE# SKILLS section cannot be rendered (RC2 used to be silent)._skills_omit_warned: bool = False@@ -5354,7 +5358,7 @@ class BrainManager:self._skill_relevance = Noneself._skill_match_band = "none"self._skill_match_class = ""- self._skill_authoring_turn = False+ self._skill_meta_turn = ""try:from jarvis.skills import guards, match_eval, match_logfrom jarvis.skills.autofire_policy import classify, may_capture@@ -5362,12 +5366,12 @@ class BrainManager:ctx = try_get_skill_context()if ctx is None:- # No registry to look anything up in — but an authoring request- # is still recognisable from the words alone, and the flag is- # what keeps the create-skill tool in charge of the turn.- from jarvis.skills.authoring_request import is_skill_authoring_request+ # No registry to look anything up in — but a request ABOUT+ # skills is still recognisable from the words alone, and the+ # flag is what keeps the skill tools in charge of the turn.+ from jarvis.skills.authoring_request import skill_meta_kind- self._skill_authoring_turn = is_skill_authoring_request(user_text)+ self._skill_meta_turn = skill_meta_kind(user_text) or ""return None# Channel 0 (2026-08-12): the user NAMED a skill ("nutz den Skill@@ -5419,8 +5423,22 @@ class BrainManager:authoring = resolve_skill_authoring_request(user_text, ctx.registry)if authoring is not None:- self._skill_authoring_turn = True+ self._skill_meta_turn = authoring.kindauthoring_skill = authoring.skill+ if authoring.kind == "lifecycle":+ # "deaktiviere / lösch / zeig … den Skill X": the brand+ # skill named inside must not run; the skill app-commands+ # (skill-enable / skill-disable / skill-delete /+ # skills-list) own the turn.+ log.info(+ "skill lifecycle request — no domain skill may capture "+ "this turn; the skill app-commands own it"+ )+ self._record_skill_decision(+ user_text, authoring.decision, lang=lang,+ vetoed_by=guards.VETO_LIFECYCLE_REQUEST,+ )+ return Noneif authoring_skill is None:log.info("skill authoring request — no domain skill may capture "@@ -8220,8 +8238,11 @@ class BrainManager:# tool (one bounded LLM call, lands as a draft) — never a background# mission, even when the skill-creator builtin is disabled and no skill# captured the turn above.- if getattr(self, "_skill_authoring_turn", False):- log.info("force-spawn skipped: skill authoring request — create-skill owns it")+ if getattr(self, "_skill_meta_turn", ""):+ log.info(+ "force-spawn skipped: skill %s request — the skill tools own it",+ self._skill_meta_turn,+ )return False# A connected CLI's capability already covers this intent → prefer its# cli_<name> tool, never a Computer-Use spawn (the CLI does it headless,diff --git a/jarvis/cli_ctl/command_index.py b/jarvis/cli_ctl/command_index.pynew file mode 100644index 0000000000..710534477b--- /dev/null+++ b/jarvis/cli_ctl/command_index.py@@ -0,0 +1,179 @@+"""The `jarvisctl` command tree as plain data — what the brain's CLI tool shows.++Why this exists (voice session 2026-08-18 17:51): the brain wanted to create a+skill, knew `cli_jarvisctl` existed and nothing about its commands, and spent+three tool rounds — `jarvisctl --help`, `jarvisctl skills --help`,+`jarvisctl skills draft --help` — reading help text until the 45 s loop+deadline ended the turn. The CLI catalog gives the tool six example commands;+everything else the model had to discover at the user's expense, one slow+provider round per `--help`. That is not a skills problem: it is the same for+workflows, modes, tasks, wiki, board, contacts, missions — every group the CLI+has and the model cannot see.++So the tool description carries the whole tree: one line per group, the+command names, and for the commands a spoken request most often lands on, the+argument shape in angle brackets. Roughly 1.6 k characters — the price of one+tool schema, paid once per prompt build, against several `--help` rounds paid+per turn.++Static on purpose. Importing ``jarvis.cli_ctl.__main__`` costs ~5 s on a cold+process (Typer plus every command module), which has no place on the brain+build path (AP-26). Drift is impossible to miss instead of impossible to make:+``tests/unit/cli_ctl/test_command_index_parity.py`` walks the live Typer app+and fails the moment a group or command name here disagrees with it.+"""++from __future__ import annotations++#: ``group -> (command, ...)``. A command may carry an argument hint after a+#: space (``'create "<what it should do>" [--name --trigger --schedule]'``);+#: the parity test compares only the first token. Order: the groups a spoken+#: request most often needs first, then the rest alphabetically.+COMMAND_INDEX: dict[str, tuple[str, ...]] = {+ "skills": (+ "list",+ "show <name>",+ 'create "<what it should do>" [--name --trigger --schedule --language]',+ 'draft "<what it should do>"',+ "commit --draft <json>",+ "enable <name>",+ "disable <name>",+ "reload",+ "import <folder-or-url>",+ 'catalog-search "<query>"',+ "catalog-install <name> --source-url --title",+ ),+ "brain": (+ "status",+ "list",+ "switch <provider>",+ "subagent-switch <provider>",+ "test <provider>",+ "deep-model",+ ),+ "config": ("get <key>", "list", "set <key> <value>", "language get", "language set <de|en|es>"),+ "wiki": (+ 'recall "<query>"',+ "page <path>",+ "tree",+ "vaults",+ "health",+ 'ingest "<text>"',+ "reindex",+ "backfill",+ ),+ "ultrawiki": (+ 'ask "<question>"',+ "topics",+ "topic <name>",+ "moments",+ "graph",+ "vault",+ "export",+ "register",+ ),+ "missions": (+ "list",+ "show <id>",+ "result <id>",+ "tool-approvals",+ "approve-tool",+ "deny-tool",+ "dispatch",+ "cancel <id>",+ "rerun <id>",+ "kill <id>",+ ),+ "tasks": ("list", "get <id>", "create", "cancel <id>", "delete <id>"),+ "modes": ("list", "show <slug>", "use <slug>", "create", "delete <slug>", "restore"),+ "workflows": ("list", "show <id>", "create", "run <id>", "delete <id>", "run-history"),+ "sessions": (+ "list",+ "latest-turn",+ "show <id>",+ "delete <id>",+ "resume <id>",+ 'speak "<text>"',+ ),+ "outputs": (+ "list",+ "plan",+ "files <slug>",+ "graph",+ "openers",+ "open-with",+ "preferred-opener",+ ),+ "contacts": ("list", "show <name>", "add", "edit <name>", "delete <name>", "import", "export"),+ "board": ("summary", "heatmap", "records", "achievements", "bio", "bio-regenerate", "profile"),+ "docs": ("list", "tree", 'search "<query>"', "show <path>"),+ "system": ("restart", "audio-devices", "status"),+ "auth": ("login", "status", "logout"),+ "clis": (+ "list",+ "show <name>",+ "check <name>",+ "install <name>",+ "connect <name>",+ "disconnect <name>",+ "usage",+ "usage-stats",+ ),+ "commands": ("list", "show <id>"),+ "computer-use": ("start", "list", "show <id>", "cancel <id>", "cancel-all"),+ "conductor": ("list", "show <id>", "add", "run <id>", "toggle <id>", "delete <id>"),+ "friends": (+ "list",+ "show <name>",+ "add",+ "edit <name>",+ "delete <name>",+ "messages <name>",+ 'message <name> "<text>"',+ ),+ "frontier": ("pending", "ack"),+ "ide": ("rename-terminal", "close-terminals"),+ "marketplace": (+ "install <id>",+ "browse",+ "list",+ "connect-pat",+ "connect-start",+ "connect-poll",+ "disconnect <id>",+ ),+ "mcps": (+ "list",+ "enable <name>",+ "disable <name>",+ "check <name>",+ "import-claude-desktop",+ "delete <name>",+ ),+ "permissions": ("status", "request", "open-settings"),+ "socials": ("list", "add", "edit", "delete"),+ "telephony": ("status", "config", "outbound"),+}++#: Top-level commands that are not in a group.+TOP_LEVEL_COMMANDS: tuple[str, ...] = ("version", "refresh")+++def command_names(group: str) -> tuple[str, ...]:+ """The bare command names of ``group`` (hints stripped)."""+ return tuple(entry.split(" ", 1)[0] for entry in COMMAND_INDEX.get(group, ()))+++def render_command_index() -> str:+ """The tree as the tool description shows it — one line per group."""+ lines = [+ "Command index (`jarvisctl <group> <command> [args]`; call the command "+ "directly — do not spend rounds on --help):",+ ]+ for group, commands in COMMAND_INDEX.items():+ lines.append(f" {group}: " + ", ".join(commands))+ lines.append(" top-level: " + ", ".join(TOP_LEVEL_COMMANDS))+ return "\n".join(lines)+++__all__ = ["COMMAND_INDEX", "TOP_LEVEL_COMMANDS", "command_names", "render_command_index"]diff --git a/jarvis/clis/tool.py b/jarvis/clis/tool.pyindex 6a3cf89d2e..59039e9b56 100644--- a/jarvis/clis/tool.py+++ b/jarvis/clis/tool.py@@ -104,9 +104,21 @@ class CliTool:def _build_description(spec: CliSpec) -> str:lines = [f"{spec.display_name} — {spec.description}"]if spec.tool_schema_examples:- lines.append("Beispiele:")+ lines.append("Examples:")for ex in spec.tool_schema_examples:lines.append(f" - {ex}")+ # Jarvis's own CLI ships its whole command tree in the description, so+ # the model calls `jarvisctl skills enable X` directly instead of+ # discovering it through `--help` rounds (2026-08-18: three such rounds+ # ate a 45 s tool budget). Static data, parity-tested against the live+ # Typer app — never an import of the CLI on the brain build path.+ if spec.binary_name == "jarvisctl":+ try:+ from jarvis.cli_ctl.command_index import render_command_index++ lines.append(render_command_index())+ except Exception: # noqa: BLE001 — a missing index costs help rounds, not the tool+ log.debug("jarvisctl command index unavailable", exc_info=True)return "\n".join(lines)async def execute(self, args: dict[str, Any], ctx: ExecutionContext) -> ToolResult:diff --git a/jarvis/commands/registry.py b/jarvis/commands/registry.pyindex 32f1848e57..e234711d49 100644--- a/jarvis/commands/registry.py+++ b/jarvis/commands/registry.py@@ -924,6 +924,117 @@ def _build_registry() -> tuple[AppCommand, ...]:"es": ("cancela la tarea",), # i18n-allow: input vocab},),+ # ------------------------------------------------------------ skills+ # The lifecycle of an installed skill by voice — the sibling of the+ # create-skill router tool (which WRITES a skill). Live gap 2026-08-18:+ # a voice-authored skill lands as a draft, and "aktiviere den Skill+ # Morgenroutine" had no tool at all — the model could only discover+ # `jarvisctl skills enable` through help rounds. Every entry maps to+ # the same route the Skills view calls. Enabling a DRAFT is the human+ # promotion AP-15 requires and is asked for out loud, so it needs no+ # second confirmation; deleting a skill removes a file the user wrote+ # or authored — dangerous, echo-confirmed. None is worker_allowed: a+ # mission worker has no business switching the user's skills (AP-5).+ AppCommand(+ id="skills-list",+ title="List installed skills",+ description=(+ "List the installed skills with their state (active, draft, "+ "disabled) and what starts each one. Use this when the user asks "+ "which skills they have or which are drafts / switched off."+ ),+ method="GET",+ path="/api/skills/brief",+ params={"type": "object", "properties": {}},+ ui_section="skills",+ voice_aliases={+ "de": ("welche skills habe ich", "zeig mir meine skills"), # i18n-allow: vocab+ "en": ("which skills do i have", "show me my skills"),+ "es": ("qué skills tengo", "muéstrame mis skills"), # i18n-allow: vocab+ },+ ),+ AppCommand(+ id="skill-enable",+ title="Enable a skill",+ description=(+ "Switch an installed skill ON by name — this is how a draft the "+ "assistant just wrote (create-skill) or a disabled skill starts "+ "firing on its trigger phrase and schedule. Use the exact skill "+ "name; list the skills first when unsure."+ ),+ method="POST",+ path="/api/skills/{name}/enable",+ params={+ "type": "object",+ "properties": {+ "name": _str_param(+ "Exact name of the skill to switch on.", min_length=1, max_length=120+ ),+ },+ "required": ["name"],+ },+ path_params=("name",),+ ui_section="skills",+ voice_aliases={+ "de": ("aktiviere den skill", "schalte den skill ein"), # i18n-allow: input vocab+ "en": ("enable the skill", "switch the skill on"),+ "es": ("activa el skill",), # i18n-allow: input vocab+ },+ ),+ AppCommand(+ id="skill-disable",+ title="Disable a skill",+ description=(+ "Switch an installed skill OFF by name — it stops firing on its "+ "trigger phrase and schedule but stays installed. Use the exact "+ "skill name; list the skills first when unsure."+ ),+ method="POST",+ path="/api/skills/{name}/disable",+ params={+ "type": "object",+ "properties": {+ "name": _str_param(+ "Exact name of the skill to switch off.", min_length=1, max_length=120+ ),+ },+ "required": ["name"],+ },+ path_params=("name",),+ ui_section="skills",+ voice_aliases={+ "de": ("deaktiviere den skill", "schalte den skill aus"), # i18n-allow: input vocab+ "en": ("disable the skill", "switch the skill off"),+ "es": ("desactiva el skill",), # i18n-allow: input vocab+ },+ ),+ AppCommand(+ id="skill-delete",+ title="Delete a skill",+ description=(+ "Delete an installed user skill by name — removes its folder for "+ "good (built-in skills cannot be deleted; disable them instead)."+ ),+ method="DELETE",+ path="/api/skills/{name}",+ params={+ "type": "object",+ "properties": {+ "name": _str_param(+ "Exact name of the skill to delete.", min_length=1, max_length=120+ ),+ },+ "required": ["name"],+ },+ path_params=("name",),+ dangerous=True,+ ui_section="skills",+ voice_aliases={+ "de": ("lösch den skill",), # i18n-allow: input vocab+ "en": ("delete the skill",),+ "es": ("elimina el skill",), # i18n-allow: input vocab+ },+ ),# ------------------------------------------------------- agentic IDE# The Agentic IDE runs coding agents in named terminals; these three# commands are what make the workspace addressable by voice. Reading isdiff --git a/jarvis/plugins/tool/create_skill.py b/jarvis/plugins/tool/create_skill.pyindex 46e435c4fa..761e72d1d8 100644--- a/jarvis/plugins/tool/create_skill.py+++ b/jarvis/plugins/tool/create_skill.py@@ -237,7 +237,9 @@ class CreateSkillTool:f"Skill '{authored.name}' is written and waiting as a DRAFT in the ""Skills view. Tell the user in one or two sentences what it does ""and when it fires, and that they activate it there — until "- "then it does not run. Do not read the instructions aloud."+ "then it does not run. Only if the user explicitly asked for it "+ "to be switched on right away, call skill-enable with this exact "+ "name now; never enable unasked. Do not read the instructions aloud."),}_LOG.info(diff --git a/jarvis/skills/authoring_request.py b/jarvis/skills/authoring_request.pyindex ca128ae8ca..ed8b9e3ac2 100644--- a/jarvis/skills/authoring_request.py+++ b/jarvis/skills/authoring_request.py@@ -1,4 +1,4 @@-"""Deterministic resolution of "create a skill that …" — the user asked for a NEW skill.+"""Deterministic resolution of requests ABOUT skills — create one, or manage one.Live failure this module exists for (voice session 2026-08-18 17:51): theuser asked, in German, for a new "morning routine" skill — read the mail,@@ -16,41 +16,59 @@ builtin's own trigger missed because it only knew the German infinitive("… Skill erstellst").The rule this resolver states is simple and holds regardless of vocabulary:-**when the user asks to CREATE a skill, every service they name is the CONTENT-of that skill, never a command to that service.** A brand mentioned inside an-authoring request must not capture the turn.+**when the user talks ABOUT a skill — asks for a new one, or asks to switch+one off, delete it, list them — every service they name is the CONTENT of that+request, never a command to that service.** A brand mentioned inside such a+request must not capture the turn.-Same spirit as :mod:`jarvis.skills.explicit_request` — pure CPU, no LLM, no IO-(AP-9/AP-11 safe), precision over recall. It fires only when ALL hold:+Two kinds of request, same spirit as :mod:`jarvis.skills.explicit_request` —+pure CPU, no LLM, no IO (AP-9/AP-11 safe), precision over recall:-1. the literal word "skill(s)" — the user is talking about the mechanism,-2. the skill word is the OBJECT of a creation, in one of three shapes:+**Authoring** — the user wants a NEW skill. Fires only when ALL hold:++1. an internal-artifact noun — the literal word "skill(s)", or one of its+ spoken synonyms in this product: routine (incl. compounds such as+ "morning routine" as one word), automation, workflow, and their German+ and Spanish forms (see ``_ARTIFACT_NOUN``),+2. the noun is the OBJECT of a creation, in one of three shapes:an indefinite / "new" article before it ("einen neuen Skill", "a skill",- "un skill"), a creation verb right after it in any spoken conjugation- ("Skill erstellst", "skill zu erstellen"), or a creation verb right before- it ("erstell skill morgenroutine", "create skill …"),+ "eine Abendroutine"), a creation verb right after it in any spoken+ conjugation ("Skill erstellst", "skill zu erstellen"), or a creation verb+ right before it ("erstell skill morgenroutine", "create skill …"),3. the utterance is NOT an informational question ("wie erstelle ich einenskill?" must be answered, never acted on).-"use skill X" has no creation shape (that is the explicit-request resolver's-turn), "switch skill X off" has a definite article and no creation verb, "which-skills do I have" has no verb at all, "make me an overview of my skills" names-the skills only in the genitive, "write me a mail" has no skill word — in every-language the resolver knows. All of these miss by design (see the hard-negatives in the tests).--Resolution returns the ``skill-creator`` builtin as the capturing skill when it-is installed and active — trigger-grade, so it inherits the trigger channel's-unconditional capture and stand-down rights. When that builtin is disabled or-absent the turn is still marked as an authoring request so no OTHER skill may-capture it; the ``create-skill`` router tool then owns the turn on its own.+**Lifecycle** — the user wants an existing skill switched off / on, deleted,+listed or shown. Fires only when the literal word "skill(s)" is present+together with a lifecycle verb (EN "disable", "delete", "remove", "show",+"list" and their German / Spanish stems in ``_LIFECYCLE_VERB_RE``), and the+utterance is not an information question. The+`explicit-request` resolver ("nutz / starte / aktiviere den Skill X" on an+ACTIVE named skill) runs BEFORE this one in the manager and keeps its rights;+this kind covers what that resolver cannot — a draft to enable, a skill to+delete, the list — and hands the turn to the app-command tools+(``skill-enable``, ``skill-disable``, ``skill-delete``, ``skills-list``).++"use skill X" has no creation shape and no lifecycle verb (that is the+explicit-request resolver's turn), "switch the light off" has no skill word,+"which skills do I have" is a question (answered, not acted on), "make me an+overview of my skills" names the skills only in the genitive, "write me a+mail" has no skill word — in every language the resolver knows. All of these+miss by design (see the hard negatives in the tests).++Resolution returns the ``skill-creator`` builtin as the capturing skill for an+authoring request when it is installed and active — trigger-grade, so it+inherits the trigger channel's unconditional capture and stand-down rights.+When that builtin is disabled or absent, and for every lifecycle request, the+turn is still marked so no OTHER skill may capture it; the ``create-skill``+router tool or the skill app-commands then own the turn on their own."""from __future__ import annotationsimport refrom dataclasses import dataclass-from typing import Any+from typing import Any, Literalfrom jarvis.skills.explicit_request import _INFO_QUESTION_OPENER_RE, _SKILL_WORD_REfrom jarvis.skills.match_eval import (@@ -68,12 +86,28 @@ from jarvis.skills.match_eval import (#: who disables it opts out of the instruction card, not out of the protection.AUTHORING_SKILL_NAME = "skill-creator"+MetaKind = Literal["authoring", "lifecycle"]++# The internal-artifact nouns a spoken authoring request uses for "a skill" in+# this product (the skill-creator builtin's own ``intent_objects`` vocabulary,+# plus their compounds and plurals): skill, routine (incl. compounds),+# automation, workflow, and their German and Spanish forms. A brand skill's+# trigger must lose to a request that creates ANY of these — "build me an+# automation that summarises Slack on Mondays" is the same failure as the live+# one, one synonym away.+_ARTIFACT_NOUN = (+ r"(?:skills?|\w*routinen?|automatisierung(?:en)?|automations?|" # i18n-allow: speech vocab+ r"workflows?|abl[äa]uf\w*|f[äa]higkeit(?:en)?|" # i18n-allow: speech vocab+ r"rutinas?|automatizaci[óo]n(?:es)?|flujos?)" # i18n-allow: speech vocab+)+_ARTIFACT_NOUN_RE = re.compile(rf"\b{_ARTIFACT_NOUN}\b", re.IGNORECASE)+# Creation verbs, DE / EN / ES, as STEMS so every spoken conjugation matches# ("erstell", "erstellst", "erstellen", "erstelle"; "create", "creates",# "creating"; "crea", "crear", "creas"). Umlaut and digraph forms both listed.# Deliberately EXCLUDES the run/use verbs ("nutz", "starte", "run", "use") —# those belong to :mod:`jarvis.skills.explicit_request` — and the delete /-# disable verbs, because removing a skill is not authoring one.+# disable verbs, which are the LIFECYCLE kind below._VERB_STEMS = (# Germanr"erstell\w*|erzeug\w*|kreier\w*|generier\w*|entwick\w*|entwerf\w*|" # i18n-allow: speech vocab@@ -87,9 +121,9 @@ _VERB_STEMS = (r"a[ñn]ad\w*|agreg\w*|configur\w*" # i18n-allow: speech vocab)-# Shape A — an indefinite or "new" article ahead of the skill word. Up to two-# words may sit between them ("einen ganz neuen skill", "a brand new skill"),-# but never a genitive / possessive / definite word: "eine Übersicht MEINER # i18n-allow: example+# Shape A — an indefinite or "new" article ahead of the noun. Up to two words+# may sit between them ("einen ganz neuen skill", "a brand new skill"), but+# never a genitive / possessive / definite word: "eine Übersicht MEINER # i18n-allow: example# skills" and "a list OF my skills" are requests ABOUT skills, not for one._GAP_STOP = (r"meiner|meine|meinen|meines|deiner|deine|seiner|ihrer|" # i18n-allow: speech vocab@@ -97,23 +131,23 @@ _GAP_STOP = (r"my|your|his|her|our|their|of|the|these|those|all|"r"de|mis|tus|sus|los|las|del" # i18n-allow: speech vocab)-_INDEFINITE_SKILL_RE = re.compile(+_INDEFINITE_NOUN_RE = re.compile(r"\b(?:ein(?:e|en|es)?|neue[nrs]?|a|an|another|new|" # i18n-allow: speech vocabr"un|una|nuevo|nueva|otro|otra)\s+" # i18n-allow: speech vocab- rf"(?:(?!(?:{_GAP_STOP})\b)[\w-]+\s+){{0,2}}skills?\b",+ rf"(?:(?!(?:{_GAP_STOP})\b)[\w-]+\s+){{0,2}}{_ARTIFACT_NOUN}\b",re.IGNORECASE,)-# Shape B — a creation verb shortly AFTER the skill word (German verb-final-# clauses: "… einen skill erstellst", "… skill zu erstellen", "skill für mich # i18n-allow: example+# Shape B — a creation verb shortly AFTER the noun (German verb-final clauses:+# "… einen skill erstellst", "… skill zu erstellen", "skill für mich # i18n-allow: example# bauen"). Only the unambiguous creation stems here — "mach", "leg", "turn",-# "add" after a skill word are usually toggles ("mach den skill AN"). A German+# "add" after a noun are usually toggles ("mach den skill AN"). A German# participle inside a relative clause ("den skill, den du gestern erstellt# HAST") and an English past tense ("the skill I createD") describe an# EXISTING skill and are excluded, so "starte den skill den du erstellt hast"# and "run the skill I created" stay with the run/use paths.-_SKILL_THEN_VERB_RE = re.compile(- r"\bskills?\s+(?:[\w-]+\s+){0,3}(?:"+_NOUN_THEN_VERB_RE = re.compile(+ rf"\b{_ARTIFACT_NOUN}\s+(?:[\w-]+\s+){{0,3}}(?:"r"(?:erstell\w*|erzeug\w*|kreier\w*|generier\w*|anleg\w*|" # i18n-allow: speech vocabr"einricht\w*|schreib\w*|bau\w*|entwick\w*|entwerf\w*|" # i18n-allow: speech vocabr"programmier\w*)" # i18n-allow: speech vocab@@ -129,37 +163,57 @@ _SKILL_THEN_VERB_RE = re.compile(re.IGNORECASE,)-# Shape C — a creation verb right BEFORE the skill word, with only politeness /+# Shape C — a creation verb right BEFORE the noun, with only politeness /# indefinite glue between ("erstell mir mal skill morgenroutine", "create skill# …", "haz un skill"). Definite articles are NOT glue: "mach DEN skill aus". # i18n-allow: example-_VERB_THEN_SKILL_RE = re.compile(+_VERB_THEN_NOUN_RE = re.compile(rf"\b(?:{_VERB_STEMS})\s+"r"(?:(?:mir|me|uns|us|bitte|please|doch|mal|jetzt|now|schnell|" # i18n-allow: speech vocabr"quick(?:ly)?|einen?|neuen?|new|a|an|un|una|nuevo|nueva|otro|otra)" # i18n-allow: speech vocabr"\s+){0,4}"- r"skills?\b",+ rf"{_ARTIFACT_NOUN}\b",re.IGNORECASE,)_ANY_VERB_RE = re.compile(rf"\b(?:{_VERB_STEMS})\b", re.IGNORECASE)+# Lifecycle verbs, DE / EN / ES, as stems. "aktivier" is here too: on an ACTIVE+# named skill the explicit-request resolver already claimed it as a use-verb+# and runs first; what reaches this resolver is "aktiviere den Skill X" for a+# DRAFT or disabled skill — an enable, not a run. Deliberately excludes the+# creation verbs above and the run/use verbs.+_LIFECYCLE_VERB_RE = re.compile(+ r"\b(?:"+ r"deaktivier\w*|aktivier\w*|abschalt\w*|ausschalt\w*|einschalt\w*|" # i18n-allow: speech vocab+ r"l[öo]sch\w*|loesch\w*|entfern\w*|zeig\w*|list\w*|auflist\w*|" # i18n-allow: speech vocab+ r"schalt\w*|" # i18n-allow: speech vocab+ r"disable\w*|enable\w*|delete\w*|remove\w*|show\w*|turn\s+(?:on|off)|"+ r"switch\s+(?:on|off)|"+ r"desactiv\w*|activ\w*|elimin\w*|borr\w*|muestr\w*|mostrar|quit\w*" # i18n-allow: speech vocab+ r")\b",+ re.IGNORECASE,+)+@dataclass(frozen=True, slots=True)class AuthoringResolution:- """What an authoring request resolved to.+ """What a request ABOUT skills resolved to.- ``skill`` is the active ``skill-creator`` builtin when installed, else- ``None`` — the turn is an authoring request either way (that is what- ``decision`` records), the difference is only whether an instruction card- captures it or the ``create-skill`` tool stands alone.+ ``kind`` is ``"authoring"`` (a new skill) or ``"lifecycle"`` (switch off /+ on, delete, list, show). ``skill`` is the active ``skill-creator`` builtin+ for an authoring request when installed, else ``None`` — the turn is a+ meta request either way (that is what ``decision`` records); the+ difference is only whether an instruction card captures it or the router+ tools stand alone."""skill: Any | Nonedecision: MatchDecision+ kind: MetaKind = "authoring"def is_skill_authoring_request(utterance: str) -> bool:- """True when the user asks for a NEW skill to be created.+ """True when the user asks for a NEW skill (or routine / automation …).Pure regex, no registry: usable by the force-spawn guard and the evidencegate before any skill lookup. Never raises.@@ -167,7 +221,7 @@ def is_skill_authoring_request(utterance: str) -> bool:if not utterance:return Falsetry:- if not _SKILL_WORD_RE.search(utterance):+ if not _ARTIFACT_NOUN_RE.search(utterance):return Falseif not _ANY_VERB_RE.search(utterance):return False@@ -175,26 +229,64 @@ def is_skill_authoring_request(utterance: str) -> bool:# A question ABOUT creating skills must be ANSWERED, never acted on.return Falsereturn bool(- _INDEFINITE_SKILL_RE.search(utterance)- or _SKILL_THEN_VERB_RE.search(utterance)- or _VERB_THEN_SKILL_RE.search(utterance)+ _INDEFINITE_NOUN_RE.search(utterance)+ or _NOUN_THEN_VERB_RE.search(utterance)+ or _VERB_THEN_NOUN_RE.search(utterance))except Exception: # noqa: BLE001 — detection must never break a turnreturn False+def is_skill_lifecycle_request(utterance: str) -> bool:+ """True when the user asks to switch off / on, delete, list or show a SKILL.++ The literal word "skill(s)" is required — "switch the light off" names no+ skill and stays with the smart-home connector. Never raises.+ """+ if not utterance:+ return False+ try:+ if not _SKILL_WORD_RE.search(utterance):+ return False+ if not _LIFECYCLE_VERB_RE.search(utterance):+ return False+ if _INFO_QUESTION_OPENER_RE.match(utterance):+ return False+ return True+ except Exception: # noqa: BLE001 — detection must never break a turn+ return False+++def skill_meta_kind(utterance: str) -> MetaKind | None:+ """``"authoring"``, ``"lifecycle"`` or ``None`` — creation outranks lifecycle+ ("create a new skill and delete the old one" is authoring first)."""+ if is_skill_authoring_request(utterance):+ return "authoring"+ if is_skill_lifecycle_request(utterance):+ return "lifecycle"+ return None++def resolve_skill_authoring_request(utterance: str, registry: Any) -> AuthoringResolution | None:- """Resolve "create a skill …" to the authoring builtin, or to "nobody".-- Returns ``None`` when the utterance is not an authoring request at all.- Otherwise returns an :class:`AuthoringResolution` whose ``decision``- carries ``SOURCE_TRIGGER`` / ``BAND_FIRE`` when ``skill-creator`` is active- (a stated intent is trigger-grade evidence, exactly like a spoken skill- name), and an empty ``BAND_NONE`` decision when the builtin is unavailable- — the caller then lets NO skill capture. Never raises.+ """Resolve a request ABOUT skills to the authoring builtin, or to "nobody".++ Returns ``None`` when the utterance is neither an authoring nor a lifecycle+ request. Otherwise returns an :class:`AuthoringResolution` whose+ ``decision`` carries ``SOURCE_TRIGGER`` / ``BAND_FIRE`` when an authoring+ request meets an active ``skill-creator`` (a stated intent is trigger-grade+ evidence, exactly like a spoken skill name), and an empty ``BAND_NONE``+ decision otherwise — the caller then lets NO skill capture. Never raises."""- if not is_skill_authoring_request(utterance):+ kind = skill_meta_kind(utterance)+ if kind is None:return None+ nobody = AuthoringResolution(+ skill=None,+ decision=MatchDecision(band=BAND_NONE, source=SOURCE_NONE),+ kind=kind,+ )+ if kind == "lifecycle":+ return nobodytry:skill = Noneif registry is not None:@@ -203,10 +295,7 @@ def resolve_skill_authoring_request(utterance: str, registry: Any) -> AuthoringRskill = candidatebreakif skill is None:- return AuthoringResolution(- skill=None,- decision=MatchDecision(band=BAND_NONE, source=SOURCE_NONE),- )+ return nobodycandidate = MatchCandidate(skill_name=AUTHORING_SKILL_NAME,score=TRIGGER_MATCH_SCORE,@@ -221,16 +310,17 @@ def resolve_skill_authoring_request(utterance: str, registry: Any) -> AuthoringRtop=candidate,candidates=(candidate,),)- return AuthoringResolution(skill=skill, decision=decision)+ return AuthoringResolution(skill=skill, decision=decision, kind="authoring")except Exception: # noqa: BLE001 — resolution must never break a turn- return AuthoringResolution(- skill=None, decision=MatchDecision(band=BAND_NONE, source=SOURCE_NONE)- )+ return nobody__all__ = ["AUTHORING_SKILL_NAME","AuthoringResolution",+ "MetaKind","is_skill_authoring_request",+ "is_skill_lifecycle_request","resolve_skill_authoring_request",+ "skill_meta_kind",]diff --git a/jarvis/skills/builtin/skill-creator/SKILL.md b/jarvis/skills/builtin/skill-creator/SKILL.mdindex c34b57abb0..a21636ad50 100644--- a/jarvis/skills/builtin/skill-creator/SKILL.md+++ b/jarvis/skills/builtin/skill-creator/SKILL.md@@ -71,8 +71,14 @@ The user wants a NEW skill. Write it for them — do not interview them.3. If the result says no model could write it, say so plainly and offer to tryagain in a moment. Do not fall back to a worker and do not paste the requestinto a file yourself.-4. If the user asks to change an EXISTING skill, tell them that editing lives in- the Skills view (this card only creates); name the skill they mean.+4. The new skill is a draft. Only when the user explicitly asked for it to be+ switched on right away ("und aktiviere ihn gleich"), call `skill-enable`+ with the name the result returned — never enable unasked. Switching a skill+ off, on, or deleting one is `skill-disable` / `skill-enable` /+ `skill-delete`; the list is `skills-list`.+5. If the user asks to change an EXISTING skill's content, tell them that+ editing lives in the Skills view (this card only creates); name the skill+ they mean.## Answer formatdiff --git a/jarvis/skills/guards.py b/jarvis/skills/guards.pyindex 5ea5aba186..bccd8305d8 100644--- a/jarvis/skills/guards.py+++ b/jarvis/skills/guards.py@@ -61,6 +61,9 @@ VETO_PLUGIN_NOT_CONNECTED = "plugin_not_connected"# via :mod:`jarvis.skills.authoring_request` when the ``skill-creator`` builtin# is not available to take the turn itself.VETO_AUTHORING_REQUEST = "authoring_request"+# The user asked to switch off / on, delete, list or show a SKILL by name — a+# lifecycle request; the brand skill named inside must not run.+VETO_LIFECYCLE_REQUEST = "skill_lifecycle_request"VETO_REASONS: frozenset[str] = frozenset({VETO_DEFINITIONAL,@@ -77,6 +80,7 @@ VETO_REASONS: frozenset[str] = frozenset({VETO_SHADOW_MODE,VETO_PLUGIN_NOT_CONNECTED,VETO_AUTHORING_REQUEST,+ VETO_LIFECYCLE_REQUEST,})#: Guard identifiers, in the order the ladder evaluates them. Exposed so the@@ -359,6 +363,7 @@ __all__ = ["VETO_DRAFT_STATE","VETO_EXPLICIT_HEAVY","VETO_KILL_SWITCH",+ "VETO_LIFECYCLE_REQUEST","VETO_LOCAL_ACTION","VETO_NO_FRONTMATTER","VETO_REASONS",diff --git a/jarvis/ui/web/skills_routes.py b/jarvis/ui/web/skills_routes.pyindex 5934ad68b9..bcdd26be34 100644--- a/jarvis/ui/web/skills_routes.py+++ b/jarvis/ui/web/skills_routes.py@@ -338,6 +338,44 @@ async def list_skills(request: Request) -> dict[str, Any]:}[email protected]("/brief")+async def list_skills_brief(request: Request) -> dict[str, Any]:+ """The lean listing the brain reads by voice ("which skills do I have").++ ``GET /api/skills`` serialises triggers, resources, origin receipts and+ portable metadata for every skill — tens of kilobytes for an ordinary+ install, which the tool-result cap slices mid-JSON. This one carries name,+ state, a one-line description and what starts the skill; nothing else.+ Declared BEFORE ``/{name}`` so "brief" is never read as a skill name.+ """+ from jarvis.skills import prefs++ reg = _require_registry(request)+ skills: list[Skill] = _sort_by_order(reg.list(), prefs.load_order())+ out: list[dict[str, Any]] = []+ for s in skills:+ fm = s.frontmatter+ starts: list[str] = []+ for t in fm.triggers if fm else ():+ if t.type == "voice" and t.pattern:+ starts.append(f"say: {t.pattern[:60]}")+ elif t.type == "schedule" and t.cron:+ starts.append(f"cron: {t.cron}")+ elif t.type == "hotkey" and t.combo:+ starts.append(f"hotkey: {t.combo}")+ description = " ".join((fm.description if fm else "").split())+ out.append(+ {+ "name": s.name,+ "state": s.state.value,+ "is_builtin": _is_builtin(s.name),+ "description": description[:140],+ "starts": starts,+ }+ )+ return {"skills": out, "total": len(out)}++@router.post("")async def create_skill(body: SkillCreateBody, request: Request) -> dict[str, Any]:"""Creates a new user skill and returns the full detail representation.diff --git a/tests/unit/brain/test_skill_authoring_turn.py b/tests/unit/brain/test_skill_authoring_turn.pyindex b2f0f0b343..b904ec25d9 100644--- a/tests/unit/brain/test_skill_authoring_turn.py+++ b/tests/unit/brain/test_skill_authoring_turn.py@@ -10,8 +10,10 @@ instructions were injected, the model burned the tool budget onThe fix is a deterministic channel ahead of the trigger channel(``jarvis.skills.authoring_request``): an authoring request resolves to the``skill-creator`` builtin when it is active, and to NO skill otherwise —-never to a connector named inside the request. Force-spawn and the evidence-gate stand down on such a turn; the ``create-skill`` router tool owns it.+never to a connector named inside the request. The same channel recognises+LIFECYCLE requests ("deaktiviere den YouTube-Music-Skill") and lets nobody+capture those either. Force-spawn and the evidence gate stand down on such a+turn; the ``create-skill`` router tool / the skill app-commands own it."""from __future__ import annotations@@ -122,7 +124,7 @@ def test_control_music_command_is_captured_by_the_music_skill(tmp_path: Path) ->matched = m._match_skill_for_turn("spiel country roads auf youtube music") # i18n-allow: test inputassert matched is not Noneassert matched.name == "plugin-youtube_music"- assert m._skill_authoring_turn is False+ assert m._skill_meta_turn == ""# ----------------------------------------------------------------------@@ -136,7 +138,7 @@ def test_live_utterance_resolves_to_skill_creator_not_youtube_music(tmp_path: Pamatched = m._match_skill_for_turn(LIVE_UTTERANCE)assert matched is not Noneassert matched.name == "skill-creator"- assert m._skill_authoring_turn is True+ assert m._skill_meta_turn == "authoring"def test_live_utterance_captures_nobody_when_skill_creator_is_disabled(tmp_path: Path) -> None:@@ -145,13 +147,13 @@ def test_live_utterance_captures_nobody_when_skill_creator_is_disabled(tmp_path:_context(tmp_path, with_creator=False)m = _make_manager()assert m._match_skill_for_turn(LIVE_UTTERANCE) is None- assert m._skill_authoring_turn is True+ assert m._skill_meta_turn == "authoring"def test_authoring_turn_is_flagged_even_without_a_skill_context() -> None:m = _make_manager()assert m._match_skill_for_turn(LIVE_UTTERANCE) is None- assert m._skill_authoring_turn is True+ assert m._skill_meta_turn == "authoring"# ----------------------------------------------------------------------@@ -177,6 +179,34 @@ def test_flag_resets_on_the_next_probe(tmp_path: Path) -> None:_context(tmp_path, with_creator=True)m = _make_manager()m._match_skill_for_turn(LIVE_UTTERANCE)- assert m._skill_authoring_turn is True+ assert m._skill_meta_turn == "authoring"m._match_skill_for_turn("spiel country roads auf youtube music") # i18n-allow: test input- assert m._skill_authoring_turn is False+ assert m._skill_meta_turn == ""+++# ----------------------------------------------------------------------+# Lifecycle requests: the brand skill named inside must not RUN+# ----------------------------------------------------------------------+++def test_disable_request_is_not_captured_by_the_named_brand_skill(tmp_path: Path) -> None:+ """"deaktiviere den YouTube-Music-Skill" mentions the brand — the music+ skill must not run; skill-disable (app-command) owns the turn."""+ _context(tmp_path, with_creator=True)+ m = _make_manager()+ assert m._match_skill_for_turn("deaktiviere den youtube music skill") is None # i18n-allow: test input+ assert m._skill_meta_turn == "lifecycle"+ assert m._should_force_spawn("deaktiviere den youtube music skill") is False # i18n-allow: test input+++def test_a_routine_or_automation_request_is_authoring_too(tmp_path: Path) -> None:+ """One synonym away from the live bug: "build me an automation that plays+ YouTube Music on Mondays" must not hand the turn to the music skill."""+ _context(tmp_path, with_creator=True)+ m = _make_manager()+ matched = m._match_skill_for_turn(+ "bau mir eine automatisierung die montags um 9 ein lied auf youtube music spielt" # i18n-allow: test input+ )+ assert matched is not None+ assert matched.name == "skill-creator"+ assert m._skill_meta_turn == "authoring"diff --git a/tests/unit/cli_ctl/test_command_index_parity.py b/tests/unit/cli_ctl/test_command_index_parity.pynew file mode 100644index 0000000000..818b17b68e--- /dev/null+++ b/tests/unit/cli_ctl/test_command_index_parity.py@@ -0,0 +1,69 @@+"""The static `jarvisctl` command index equals the live Typer app.++The brain's ``cli_jarvisctl`` tool shows ``jarvis.cli_ctl.command_index`` in+its description so the model calls commands directly instead of reading+``--help`` for several rounds. Static data can drift; this test walks the real+Typer app (the ~5 s import is fine in a test, not on the brain build path) and+fails on any group or command that disagrees in either direction.+"""+from __future__ import annotations++from jarvis.cli_ctl.command_index import (+ COMMAND_INDEX,+ TOP_LEVEL_COMMANDS,+ command_names,+ render_command_index,+)+++def _live_tree() -> tuple[dict[str, set[str]], set[str]]:+ from jarvis.cli_ctl.__main__ import app++ groups: dict[str, set[str]] = {}+ top: set[str] = set()++ def _name(cmd) -> str: # noqa: ANN001+ return cmd.name or cmd.callback.__name__.replace("_", "-")++ for cmd in app.registered_commands:+ top.add(_name(cmd))+ for group in app.registered_groups:+ names: set[str] = set()+ inst = group.typer_instance+ for cmd in inst.registered_commands:+ names.add(_name(cmd))+ # One level of nesting is enough for this CLI (config language get/set).+ for sub in inst.registered_groups:+ for cmd in sub.typer_instance.registered_commands:+ names.add(f"{sub.name} {_name(cmd)}")+ groups[group.name] = names+ return groups, top+++def test_every_live_group_and_command_is_in_the_index() -> None:+ live, top = _live_tree()+ assert set(live) == set(COMMAND_INDEX), (+ f"groups differ — live-only: {set(live) - set(COMMAND_INDEX)}, "+ f"index-only: {set(COMMAND_INDEX) - set(live)}"+ )+ for group, names in live.items():+ indexed = set()+ for entry in COMMAND_INDEX[group]:+ # A nested command keeps its sub-group word ("language get").+ parts = entry.split(" ")+ if len(parts) > 1 and f"{parts[0]} {parts[1]}" in names:+ indexed.add(f"{parts[0]} {parts[1]}")+ else:+ indexed.add(parts[0])+ assert indexed == names, (+ f"{group}: live-only {names - indexed}, index-only {indexed - names}"+ )+ assert top == set(TOP_LEVEL_COMMANDS)+++def test_render_is_compact_and_names_the_direct_call_rule() -> None:+ text = render_command_index()+ assert "skills:" in text and "enable <name>" in text+ assert "do not spend rounds on --help" in text+ assert len(text) < 3000, len(text)+ assert command_names("skills")[:2] == ("list", "show")diff --git a/tests/unit/clis/test_tool.py b/tests/unit/clis/test_tool.pyindex 3157e5b8ce..2ea0d967d9 100644--- a/tests/unit/clis/test_tool.py+++ b/tests/unit/clis/test_tool.py@@ -245,3 +245,22 @@ async def test_stdin_is_devnull_so_reading_stdin_gets_eof(tmp_path: Path) -> Nonresult = await tool.execute({"command": cmd, "timeout_s": 5}, _ctx())assert result.success is Trueassert "STDIN_EOF" in result.output["stdout"]+++def test_jarvisctl_tool_description_carries_the_command_index(tmp_path: Path) -> None:+ """The brain's own-CLI tool shows the whole command tree, so a spoken+ request lands on `jarvisctl skills enable X` directly instead of costing+ three `--help` rounds (voice session 2026-08-18 17:51). Every other CLI+ keeps its catalog description + examples only."""+ from jarvis.clis.catalog import load_catalog++ spec = load_catalog()["jarvisctl"]+ tool = CliTool(spec, auth=CliAuthManager(), usage_log=UsageLog(db_path=tmp_path / "u.db"))+ assert "Command index" in tool.description+ assert "skills: list, show <name>" in tool.description+ assert "enable <name>" in tool.description+ assert "do not spend rounds on --help" in tool.description+ assert len(tool.description) < 4000, len(tool.description)++ other, _ = _make_tool(tmp_path)+ assert "Command index" not in other.descriptiondiff --git a/tests/unit/skills/test_authoring_request.py b/tests/unit/skills/test_authoring_request.pyindex bdbd5be84f..de07a86712 100644--- a/tests/unit/skills/test_authoring_request.py+++ b/tests/unit/skills/test_authoring_request.py@@ -16,7 +16,9 @@ import pytestfrom jarvis.skills.authoring_request import (AUTHORING_SKILL_NAME,is_skill_authoring_request,+ is_skill_lifecycle_request,resolve_skill_authoring_request,+ skill_meta_kind,)from jarvis.skills.match_eval import BAND_FIRE, BAND_NONE, SOURCE_TRIGGER@@ -72,6 +74,13 @@ LIVE_UTTERANCE = ("make me a new skill for the evening","set up a skill for my monday review","crea un skill que lea mi correo", # i18n-allow: test input+ # the product's synonyms for "a skill" — one word away from the live bug+ "erstell mir eine morgenroutine für 6 uhr", # i18n-allow: test input+ "leg eine abendroutine an, die spotify leise dreht", # i18n-allow: test input+ "bau mir eine automatisierung die jeden montag slack zusammenfasst", # i18n-allow: test input+ "erstell mir einen workflow der abends die tickets zusammenfasst", # i18n-allow: test input+ "create a routine that reads my calendar",+ "crea una rutina que lea mi correo", # i18n-allow: test input],)def test_authoring_requests_are_detected(utterance: str) -> None:@@ -106,6 +115,10 @@ def test_authoring_requests_are_detected(utterance: str) -> None:"erstell mir eine mail an das team", # i18n-allow: test input"spiel musik auf youtube music", # i18n-allow: test input"schreib eine mail an das team", # i18n-allow: test input+ # a routine RUN or a routine mentioned, not created+ "starte die morgenroutine", # i18n-allow: test input+ "was steht heute in meiner routine", # i18n-allow: test input+ "erinnere mich an meine routine", # i18n-allow: test input"",],)@@ -113,6 +126,56 @@ def test_non_authoring_requests_are_ignored(utterance: str) -> None:assert is_skill_authoring_request(utterance) is False+# ---------------------------------------------------------------------------+# Lifecycle — switch off / on, delete, list, show a SKILL+# ---------------------------------------------------------------------------+++ "utterance",+ [+ "deaktiviere den skill morgenroutine", # i18n-allow: test input+ "aktiviere den skill morgenroutine", # i18n-allow: test input+ "lösch den skill abendroutine", # i18n-allow: test input+ "schalt den spotify skill aus", # i18n-allow: test input+ "zeig mir meine skills", # i18n-allow: test input+ "disable the youtube music skill",+ "remove the skill I created yesterday",+ "desactiva el skill de spotify", # i18n-allow: test input+ ],+)+def test_lifecycle_requests_are_detected(utterance: str) -> None:+ assert is_skill_lifecycle_request(utterance) is True+ assert skill_meta_kind(utterance) == "lifecycle"+++ "utterance",+ [+ "schalt das licht aus", # i18n-allow: test input — no skill word: the smart-home connector's turn+ "mach die musik aus", # i18n-allow: test input+ "welche skills habe ich", # i18n-allow: test input — a question, answered not acted on+ "nutz den skill morning-routine bitte", # i18n-allow: test input — a use, not a lifecycle+ "starte die morgenroutine", # i18n-allow: test input+ ],+)+def test_non_lifecycle_requests_are_ignored(utterance: str) -> None:+ assert is_skill_lifecycle_request(utterance) is False+++def test_creation_outranks_lifecycle_in_one_sentence() -> None:+ assert skill_meta_kind("erstell einen neuen skill und lösch den alten skill") == "authoring" # i18n-allow: test input+++def test_lifecycle_resolves_to_nobody_even_with_skill_creator_active() -> None:+ registry = _FakeRegistry(["plugin-youtube_music", AUTHORING_SKILL_NAME])+ resolution = resolve_skill_authoring_request("deaktiviere den youtube music skill", registry) # i18n-allow: test input+ assert resolution is not None+ assert resolution.kind == "lifecycle"+ assert resolution.skill is None+ assert resolution.decision.top is None++# ---------------------------------------------------------------------------# Resolution# ---------------------------------------------------------------------------diff --git a/tests/unit/ui/web/test_skills_routes.py b/tests/unit/ui/web/test_skills_routes.pyindex 6c29b78725..45ba025679 100644--- a/tests/unit/ui/web/test_skills_routes.py+++ b/tests/unit/ui/web/test_skills_routes.py@@ -399,3 +399,26 @@ def test_list_appends_unordered_skills_by_name(skills_root: Path) -> None:names = [s["name"] for s in client.get("/api/skills").json()["skills"]]assert names[0] == "gamma"assert names[1:] == ["alpha", "beta"] # unordered remainder, sorted by name+++# ----------------------------------------------------------------------+# brief listing — what the brain reads for "which skills do I have"+# ----------------------------------------------------------------------+++def test_brief_listing_carries_state_and_starts_only(skills_root: Path) -> None:+ """``skills-list`` (app-command) reads this: lean enough for the 8 000-char+ tool-result cap, and "brief" must never be read as a skill name."""+ _make_skill(skills_root, "alpha")+ _make_skill(skills_root, "beta", state="draft")+ client, _reg = _client(skills_root)+ res = client.get("/api/skills/brief")+ assert res.status_code == 200, res.text+ body = res.json()+ assert body["total"] == 2+ by_name = {s["name"]: s for s in body["skills"]}+ assert by_name["alpha"]["state"] == "validated"+ assert by_name["beta"]["state"] == "draft"+ assert set(by_name["alpha"]) == {"name", "state", "is_builtin", "description", "starts"}+ # /{name} still resolves real names, and "brief" is not one of them.+ assert client.get("/api/skills/alpha").status_code == 200