Skip to content

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.

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.md
index 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 live
tool 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 opens
with four pictures that ship inside the app — the night original, its
daylight 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-neutral
diff --git a/docs/BUGS.md b/docs/BUGS.md
index 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.md
index 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 and
diff --git a/docs/commands-reference.md b/docs/commands-reference.md
index 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. Rev
Switch 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 star
Switch 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 f
Switch 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 status
Report 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.py
index 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 = None
self._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_log
from 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.kind
authoring_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 None
if 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.py
new file mode 100644
index 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.py
index 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.py
index 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 is
diff --git a/jarvis/plugins/tool/create_skill.py b/jarvis/plugins/tool/create_skill.py
index 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.py
index 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): the
user 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 einen
skill?" 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 annotations
import re
from dataclasses import dataclass
-from typing import Any
+from typing import Any, Literal
from jarvis.skills.explicit_request import _INFO_QUESTION_OPENER_RE, _SKILL_WORD_RE
from 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 = (
# German
r"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 vocab
r"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 vocab
r"einricht\w*|schreib\w*|bau\w*|entwick\w*|entwerf\w*|" # i18n-allow: speech vocab
r"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 vocab
r"quick(?:ly)?|einen?|neuen?|new|a|an|un|una|nuevo|nueva|otro|otra)" # i18n-allow: speech vocab
r"\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 | None
decision: 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 evidence
gate before any skill lookup. Never raises.
@@ -167,7 +221,7 @@ def is_skill_authoring_request(utterance: str) -> bool:
if not utterance:
return False
try:
- if not _SKILL_WORD_RE.search(utterance):
+ if not _ARTIFACT_NOUN_RE.search(utterance):
return False
if 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 False
return 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 turn
return 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 nobody
try:
skill = None
if registry is not None:
@@ -203,10 +295,7 @@ def resolve_skill_authoring_request(utterance: str, registry: Any) -> AuthoringR
skill = candidate
break
if skill is None:
- return AuthoringResolution(
- skill=None,
- decision=MatchDecision(band=BAND_NONE, source=SOURCE_NONE),
- )
+ return nobody
candidate = MatchCandidate(
skill_name=AUTHORING_SKILL_NAME,
score=TRIGGER_MATCH_SCORE,
@@ -221,16 +310,17 @@ def resolve_skill_authoring_request(utterance: str, registry: Any) -> AuthoringR
top=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.md
index 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 try
again in a moment. Do not fall back to a worker and do not paste the request
into 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 format
diff --git a/jarvis/skills/guards.py b/jarvis/skills/guards.py
index 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.py
index 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]:
}
+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.py
index 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 on
The 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 input
assert matched is not None
assert 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: Pa
matched = m._match_skill_for_turn(LIVE_UTTERANCE)
assert matched is not None
assert 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.py
new file mode 100644
index 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.py
index 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) -> Non
result = await tool.execute({"command": cmd, "timeout_s": 5}, _ctx())
assert result.success is True
assert "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.description
diff --git a/tests/unit/skills/test_authoring_request.py b/tests/unit/skills/test_authoring_request.py
index bdbd5be84f..de07a86712 100644
--- a/tests/unit/skills/test_authoring_request.py
+++ b/tests/unit/skills/test_authoring_request.py
@@ -16,7 +16,9 @@ import pytest
from 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.py
index 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