heyasa 0.1.1__tar.gz

heyasa-0.1.1/LICENSE

@@ -0,0 +1,110 @@
+PROPRIETARY AND CONFIDENTIAL SOURCE CODE LICENSE
+STRICT ANTI-AI / ANTI-MINING RESERVATION OF RIGHTS
+
+Copyright (c) 2026 Tomasz Sapletta Prototypowanie.pl NIP: 5881918662, REGON: 220665410. All rights reserved.
+Właścicielem oprogramowania jest Tomasz Sapletta Prototypowanie.pl NIP: 5881918662, REGON: 220665410.
+
+================================================================================
+IMPORTANT NOTICE - PROPRIETARY AND CONFIDENTIAL
+================================================================================
+
+This software, source code, documentation, specifications, schemas, models,
+algorithms, and associated digital assets ("the Software") are the confidential
+and proprietary intellectual property of Tomasz Sapletta Prototypowanie.pl
+(NIP: 5881918662, REGON: 220665410) and its licensors.
+
+The Software is NOT licensed under any open source, free software, or
+source-available license (such as MIT, Apache 2.0, BSD, GPL, AGPL, BSL, or SSPL).
+All rights not expressly granted under a separate, signed written commercial
+agreement executed by Tomasz Sapletta Prototypowanie.pl are strictly reserved.
+
+================================================================================
+SECTION 1. STRICT PROHIBITION ON ARTIFICIAL INTELLIGENCE & MACHINE LEARNING INGESTION
+================================================================================
+
+Under no circumstances may any portion of the Software, whether in human-readable
+source code, compiled binary, abstract syntax tree (AST), intermediate representation,
+documentation, ticket history, or commit metadata, be:
+
+1.1. Ingested, scraped, crawled, harvested, indexed, tokenized, cached, or stored
+     for the purpose of training, pre-training, fine-tuning, evaluating, or weighting
+     any artificial intelligence system, machine learning model, large language
+     model (LLM), code-generation model, neural network, diffusion model, or
+     multimodal model.
+
+1.2. Used by, or fed into the training datasets, prompt contexts, retrieval-augmented
+     generation (RAG) stores, vector databases, or telemetry caches of any commercial
+     or non-commercial AI system, including but not limited to:
+     - GitHub Copilot / Microsoft Copilot (Microsoft Corporation)
+     - OpenAI ChatGPT, Codex, GPT-4, GPT-5, o-series, and related APIs (OpenAI Inc.)
+     - Google Gemini, PaLM, Codey, Vertex AI, and DeepMind systems (Google LLC / Alphabet)
+     - Anthropic Claude, Constitutional AI, and related models (Anthropic PBC)
+     - Meta LLaMA, Code Llama, and related foundation models (Meta Platforms, Inc.)
+     - Amazon CodeWhisperer, Bedrock, and Titan models (Amazon.com, Inc.)
+     - Mistral AI, Cohere, Cursor AI, Tabnine, Replit Ghostwriter, or any automated
+       code-synthesis engine or AI coding assistant.
+
+1.3. Processed or analyzed by any automated tool, bot, crawler, or scraper to generate
+     synthetic code, code suggestions, autocomplete suggestions, embeddings, or
+     derivative software models.
+
+================================================================================
+SECTION 2. STATUTORY RESERVATION OF RIGHTS (EU DIRECTIVE 2019/790)
+================================================================================
+
+2.1. In accordance with Article 4(3) of Directive (EU) 2019/790 of the European
+     Parliament and of the Council on copyright and related rights in the Digital
+     Single Market, the rights holder hereby EXPRESSLY RESERVES ALL RIGHTS
+     regarding Text and Data Mining (TDM) for this Software, its source repositories,
+     documentation, schemas, and all associated materials.
+
+2.2. Any extraction, automated reading, indexing, or reproduction of the Software
+     for text and data mining purposes within the meaning of Directive (EU) 2019/790
+     is strictly prohibited without prior written authorization from the rights holder.
+
+2.3. This reservation applies worldwide and is declared in machine-readable form
+     within the repository metadata, headers, and this License specification.
+
+================================================================================
+SECTION 3. HOSTING & PLATFORM PREEMPTION CLAUSE
+================================================================================
+
+3.1. The presence of this source code or repository on any third-party hosting service,
+     code forge, version control platform, or cloud provider (including but not
+     limited to GitHub, GitLab, Bitbucket, or AWS) does NOT constitute a waiver,
+     license grant, or implied consent to the hosting provider, its parent,
+     subsidiaries, or third parties to:
+     (a) use the Software for machine learning training, telemetry harvesting, or
+         model improvement;
+     (b) distribute or reproduce the Software to other users or automated agents;
+     (c) index the Software in any public search or retrieval system.
+
+3.2. Any terms of service, platform agreements, or automated licenses purporting
+     to grant the platform operator an implied, royalty-free, or transferable
+     license to utilize hosted code for artificial intelligence development, model
+     training, or feature synthesis are hereby explicitly rejected, preempted,
+     and declared null and void with respect to this Software.
+
+================================================================================
+SECTION 4. PROHIBITED USES & RESTRICTIONS
+================================================================================
+
+Except as expressly authorized under a valid, executed commercial enterprise license
+with Tomasz Sapletta Prototypowanie.pl, you may NOT:
+- Copy, modify, adapt, translate, reverse engineer, decompile, or disassemble the Software.
+- Distribute, sublicense, rent, lease, lend, sell, or publicly display the Software.
+- Use the Software to provide competitive time-sharing, SaaS, cloud twin, or virtualization services.
+- Remove, alter, or obscure any proprietary notices, copyright labels, or license files.
+
+================================================================================
+SECTION 5. ENFORCEMENT & REMEDIES
+================================================================================
+
+Any breach of this License, including unauthorized scraping, tokenization, or ingestion
+into an artificial intelligence system, constitutes willful copyright infringement,
+unauthorized access, and breach of contract. Tomasz Sapletta Prototypowanie.pl reserves
+the right to seek immediate injunctive relief, statutory damages, compensation for commercial
+harm, and mandatory destruction of all derivative model weights, embeddings, and training
+caches containing representations of the Software.
+
+For licensing inquiries and commercial authorization, contact: tom@prototypowanie.pl / legal@clonerd.com

heyasa-0.1.1/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: heyasa
+Version: 0.1.1
+Summary: Hey Asa — Unified Autonomous CLI Shell & Multi-Protocol Gateway for willman, willpad (willmux), and subactor standardized by wellmanifest/wellman and wellmanifest/nl-*
+Author: Tom Sapletta
+Author-email: Tom Sapletta <tom@sapletta.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == "mcp"
+Provides-Extra: grpc
+Requires-Dist: grpcio>=1.60.0; extra == "grpc"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: goal>=2.1.0; python_version >= "3.12" and extra == "dev"
+Requires-Dist: costs>=0.1.53; python_version >= "3.9" and extra == "dev"
+Dynamic: license-file
+
+# Hey Asa (`heyasa`)
+
+**Unified Autonomous CLI Shell & Multi-Protocol Gateway** dla ekosystemów **`willman`**, **`willpad` (`willmux`)** oraz **`subactor`** (a także wtyczek **`dockuri`** i **`taskand`**), ustandaryzowany przez **`wellmanifest/wellman`**, **`wellmanifest/autonomy`** oraz rodzinę **`wellmanifest/nl-*`** (`nl-dsl-llm`, `nl-uri-dsl-llm`, `nl-api-llm`).
+
+## Główne właściwości
+
+- **Jedna nazwa i marka**: `heyasa` (asystent **Asa**, wake phrase: `Hey Asa`).
+- **Wybór silnika autonomicznego (`-e` / `--engine`)**:
+  - `auto` (domyślny — deterministyczny klasyfikator intencji `nl-uri-dsl-llm` + `willuri`),
+  - `willman` — kolejka zadań DAG, cykl bodźców Koru (`stimulate`), obserwacyjna samonaprawa (`willman.observation-policy/v1`), flota projektów (`ProjectFleet`), artefakty,
+  - `willpad` — sterownik przestrzeni roboczej `willmux` (okna `A`–`F`, centralny pad w trybach `quad`/`radial`/`panel`, kompaktowy czat Table 4, narzędzia okien `shot`/`ocr`/`copy`/`record`, plany z zależnościami `chat_plan`/`chat_run`, Rynek),
+  - `subactor` — kontraktowa autonomia z `../subactor` (`IntentIR v1` → `ExecutionPlan` → bramka `AQL` → `OQL` → `urirun`, Founder Control `:8091`, `subactor-shell` ACP/SQLite/Vault),
+  - `dockuri` — modularne usługi autonomiczne `proc://.../v1` (`QueueHealService`, `SelfImprovementService`, `FinancialIntegrityService`, `ScannerIndexService`),
+  - `taskand` — kapsuły wykonawcze `proc://.../v1` i workflowy przeglądarkowe `task2willmux`.
+- **Domyślne poziomy autonomii (`--autonomy`)**:
+  - **Tryb interaktywny (TTY / REPL)**: `confirm` — prezentuje plan i oczekuje na zgodę operatora przed wykonaniem mutacji,
+  - **Tryb wsadowy / agentowy (non-TTY / batch)**: `execute-once` — wykonuje maksymalnie jeden atomowy cykl i automatycznie wraca do stanu `safe`,
+  - Pozostałe tryby: `suggest` (tylko plan / `--dry-run`) oraz `auto` (w ramach jawnego grantu autonomii).
+- **Wieloprotokołowe interfejsy**:
+  - `heyasa [polecenie]` / `heyasa shell` — CLI one-shot oraz interaktywny REPL,
+  - `heyasa mcp` — serwer MCP (`stdio` oraz `streamable-http` na `:7081`) zgodny z `NUL-015`,
+  - `heyasa serve` — zunifikowany serwer REST + SSE (`:7080`),
+  - `heyasa grpc` — serwer gRPC (`:7082` oraz UDS),
+  - `heyasa acp` — serwer Agent Client Protocol v1 (`stdin/stdout` JSON-RPC),
+  - `heyasa open <uri>` — dispatcher RFC 3986 Action URI (`heyasa://`, `willpad://`, `willmux://`, `willman://`, `subactor://`, `proc://`),
+  - `heyasa switch <tool|pane|preset|next|prev>` — błyskawiczne przełączanie narzędzi na ekranie (`chat`, `files`, `willman`, `subactor`, `dockuri`, `approval`, presety `ops`/`dev`/`compact`),
+  - `heyasa hud [--top|--bottom|--bench|--export-tauri]` — uruchamianie i przełączanie okna HUD (`willmux` / `willman`) zajmującego maksymalnie **50% wysokości ekranu** (Quake-style scratchpad / Tauri v2 Wry / Chromium `--app`).
+
+
+
+## License
+
+Licensed under Apache-2.0.

heyasa-0.1.1/README.md

@@ -0,0 +1,33 @@
+# Hey Asa (`heyasa`)
+
+**Unified Autonomous CLI Shell & Multi-Protocol Gateway** dla ekosystemów **`willman`**, **`willpad` (`willmux`)** oraz **`subactor`** (a także wtyczek **`dockuri`** i **`taskand`**), ustandaryzowany przez **`wellmanifest/wellman`**, **`wellmanifest/autonomy`** oraz rodzinę **`wellmanifest/nl-*`** (`nl-dsl-llm`, `nl-uri-dsl-llm`, `nl-api-llm`).
+
+## Główne właściwości
+
+- **Jedna nazwa i marka**: `heyasa` (asystent **Asa**, wake phrase: `Hey Asa`).
+- **Wybór silnika autonomicznego (`-e` / `--engine`)**:
+  - `auto` (domyślny — deterministyczny klasyfikator intencji `nl-uri-dsl-llm` + `willuri`),
+  - `willman` — kolejka zadań DAG, cykl bodźców Koru (`stimulate`), obserwacyjna samonaprawa (`willman.observation-policy/v1`), flota projektów (`ProjectFleet`), artefakty,
+  - `willpad` — sterownik przestrzeni roboczej `willmux` (okna `A`–`F`, centralny pad w trybach `quad`/`radial`/`panel`, kompaktowy czat Table 4, narzędzia okien `shot`/`ocr`/`copy`/`record`, plany z zależnościami `chat_plan`/`chat_run`, Rynek),
+  - `subactor` — kontraktowa autonomia z `../subactor` (`IntentIR v1` → `ExecutionPlan` → bramka `AQL` → `OQL` → `urirun`, Founder Control `:8091`, `subactor-shell` ACP/SQLite/Vault),
+  - `dockuri` — modularne usługi autonomiczne `proc://.../v1` (`QueueHealService`, `SelfImprovementService`, `FinancialIntegrityService`, `ScannerIndexService`),
+  - `taskand` — kapsuły wykonawcze `proc://.../v1` i workflowy przeglądarkowe `task2willmux`.
+- **Domyślne poziomy autonomii (`--autonomy`)**:
+  - **Tryb interaktywny (TTY / REPL)**: `confirm` — prezentuje plan i oczekuje na zgodę operatora przed wykonaniem mutacji,
+  - **Tryb wsadowy / agentowy (non-TTY / batch)**: `execute-once` — wykonuje maksymalnie jeden atomowy cykl i automatycznie wraca do stanu `safe`,
+  - Pozostałe tryby: `suggest` (tylko plan / `--dry-run`) oraz `auto` (w ramach jawnego grantu autonomii).
+- **Wieloprotokołowe interfejsy**:
+  - `heyasa [polecenie]` / `heyasa shell` — CLI one-shot oraz interaktywny REPL,
+  - `heyasa mcp` — serwer MCP (`stdio` oraz `streamable-http` na `:7081`) zgodny z `NUL-015`,
+  - `heyasa serve` — zunifikowany serwer REST + SSE (`:7080`),
+  - `heyasa grpc` — serwer gRPC (`:7082` oraz UDS),
+  - `heyasa acp` — serwer Agent Client Protocol v1 (`stdin/stdout` JSON-RPC),
+  - `heyasa open <uri>` — dispatcher RFC 3986 Action URI (`heyasa://`, `willpad://`, `willmux://`, `willman://`, `subactor://`, `proc://`),
+  - `heyasa switch <tool|pane|preset|next|prev>` — błyskawiczne przełączanie narzędzi na ekranie (`chat`, `files`, `willman`, `subactor`, `dockuri`, `approval`, presety `ops`/`dev`/`compact`),
+  - `heyasa hud [--top|--bottom|--bench|--export-tauri]` — uruchamianie i przełączanie okna HUD (`willmux` / `willman`) zajmującego maksymalnie **50% wysokości ekranu** (Quake-style scratchpad / Tauri v2 Wry / Chromium `--app`).
+
+
+
+## License
+
+Licensed under Apache-2.0.

heyasa-0.1.1/heyasa/__init__.py

@@ -0,0 +1,31 @@
+"""Hey Asa — Unified Autonomous CLI Shell & Multi-Protocol Gateway."""
+from __future__ import annotations
+
+from .hud import (
+    HalfScreenWindowManager,
+    ScreenGeometry,
+    ToolSwitcher,
+    compute_half_screen_geometry,
+    launch_hud,
+    switch_tool,
+)
+from .router import HeyasaRouter
+
+__version__ = "0.1.1"
+__brand__ = "heyasa"
+__assistant__ = "Asa"
+__wake_phrase__ = "Hey Asa"
+
+__all__ = [
+    "__version__",
+    "__brand__",
+    "__assistant__",
+    "__wake_phrase__",
+    "HeyasaRouter",
+    "ToolSwitcher",
+    "HalfScreenWindowManager",
+    "ScreenGeometry",
+    "compute_half_screen_geometry",
+    "switch_tool",
+    "launch_hud",
+]

heyasa-0.1.1/heyasa/__main__.py

@@ -0,0 +1,8 @@
+"""Entrypoint for `python -m heyasa`."""
+from __future__ import annotations
+
+import sys
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

heyasa-0.1.1/heyasa/cli.py

@@ -0,0 +1,399 @@
+"""CLI entrypoint for `heyasa` — Unified Autonomous CLI Shell & Multi-Protocol Gateway."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+from typing import List, Optional
+
+from .config import (
+    AUTONOMY_MODES,
+    ENGINE_CHOICES,
+    PROTOCOL_CHOICES,
+    WILLPAD_STYLES,
+    WILLPAD_TOOLS,
+    HeyasaConfig,
+    default_autonomy_mode,
+)
+from .hud import (
+    TOOL_TARGETS,
+    WINDOW_RUNTIMES_BENCHMARK,
+    WORKSPACE_PRESETS,
+    HalfScreenWindowManager,
+    ToolSwitcher,
+)
+from .interfaces.grpc_server import HEYASA_PROTO_SPEC, HeyasaGrpcService, serve_acp_stdio
+from .interfaces.mcp_server import build_mcp_gateway_manifest, serve_mcp
+from .interfaces.rest_server import serve_rest
+from .router import HeyasaRouter
+from .shell import format_engines_table, run_interactive_shell
+from .standard.governance import run_wellman_governance
+
+KNOWN_SUBCOMMANDS = {
+    "shell",
+    "engines",
+    "status",
+    "switch",
+    "hud",
+    "window",
+    "willpad",
+    "willman",
+    "subactor",
+    "dockuri",
+    "taskand",
+    "plan",
+    "run",
+    "dsl",
+    "uri",
+    "open",
+    "catalog",
+    "snapshot",
+    "receipts",
+    "gov",
+    "serve",
+    "mcp",
+    "grpc",
+    "acp",
+}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="heyasa",
+        description=(
+            "Hey Asa (heyasa) — Zunifikowany CLI Shell i brama wieloprotokołowa dla "
+            "willman, willpad (willmux), subactor, dockuri i taskand."
+        ),
+    )
+    parser.add_argument(
+        "-e",
+        "--engine",
+        choices=ENGINE_CHOICES,
+        default="auto",
+        help="Wybór silnika autonomicznego (domyślnie: auto)",
+    )
+    parser.add_argument(
+        "-a",
+        "--autonomy",
+        choices=AUTONOMY_MODES,
+        default=None,
+        help="Poziom autonomii: suggest, confirm (domyślny interaktywnie), execute-once (domyślny wsadowo), auto",
+    )
+    parser.add_argument(
+        "-p",
+        "--protocol",
+        choices=PROTOCOL_CHOICES,
+        default="auto",
+        help="Preferowany interfejs komunikacji z silnikiem (auto, shell, rest, mcp, grpc, acp, uri)",
+    )
+    parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Potwierdź wykonanie planu zmieniającego stan (dla trybu confirm)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Alias dla --autonomy suggest (tylko kompilacja planu i Action URI bez wykonania)",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Wypisz odpowiedź jako sformatowany JSON",
+    )
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    raw_argv = list(sys.argv[1:] if argv is None else argv)
+    config = HeyasaConfig()
+    router = HeyasaRouter(config)
+
+    if not raw_argv:
+        if sys.stdin and sys.stdin.isatty():
+            return run_interactive_shell(router, initial_engine="auto", initial_autonomy="confirm")
+        raw_argv = ["status", "--json"]
+
+    # Parse global flags + positional tokens flexibly so both `heyasa "zdanie"` and `heyasa subcmd ...` work
+    parser = build_parser()
+    known, rest = parser.parse_known_args(raw_argv)
+
+    autonomy = "suggest" if known.dry_run else (known.autonomy or default_autonomy_mode())
+    engine = known.engine
+    protocol = known.protocol
+    confirmed = known.yes
+
+    if not rest:
+        return run_interactive_shell(
+            router,
+            initial_engine=engine,
+            initial_autonomy=autonomy,
+            initial_protocol=protocol,
+        )
+
+    subcmd = rest[0]
+    sub_args = rest[1:]
+
+    if subcmd == "shell":
+        return run_interactive_shell(
+            router,
+            initial_engine=engine,
+            initial_autonomy=known.autonomy or "confirm",
+            initial_protocol=protocol,
+        )
+
+    if subcmd in ("engines", "status"):
+        statuses = router.list_engines_status()
+        if known.json:
+            print(
+                json.dumps(
+                    {
+                        "schema": "heyasa.status/v1",
+                        "brand": "heyasa",
+                        "assistant": "Asa",
+                        "wake_phrase": "Hey Asa",
+                        "default_autonomy_interactive": "confirm",
+                        "default_autonomy_batch": "execute-once",
+                        "active_autonomy": autonomy,
+                        "engines": statuses,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+        else:
+            print(format_engines_table(router))
+        return 0
+
+    if subcmd == "dsl":
+        query = " ".join(sub_args).strip()
+        res = router.pipeline.interpret(query, engine_override=engine, language=config.language)
+        print(json.dumps(res, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd in ("uri", "open"):
+        target_uri = sub_args[0] if sub_args else "heyasa://willpad/pane/focus?pane=A"
+        receipt = router.dispatch(
+            target_uri,
+            engine=engine,
+            protocol=protocol,
+            autonomy_mode=autonomy,
+            confirmed=confirmed or (autonomy == "execute-once"),
+            origin="uri",
+        )
+        print(json.dumps(receipt, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd == "plan":
+        query = " ".join(sub_args).strip()
+        plan = router.compile_plan(query, engine=engine, autonomy_mode=autonomy)
+        print(json.dumps(plan, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd == "run":
+        if not sub_args:
+            print("heyasa: podaj ID planu lub polecenie do uruchomienia", file=sys.stderr)
+            return 2
+        plan_id = sub_args[0]
+        if plan_id in router.plans:
+            receipt = router.run_plan(plan_id, confirmed=True, autonomy_mode=autonomy, protocol=protocol)
+        else:
+            receipt = router.dispatch(
+                " ".join(sub_args),
+                engine=engine,
+                protocol=protocol,
+                autonomy_mode=autonomy,
+                confirmed=True,
+                origin="cli",
+            )
+        print(json.dumps(receipt, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd == "switch":
+        switcher = ToolSwitcher(router)
+        if not sub_args or sub_args[0] in ("--list", "list"):
+            print(
+                json.dumps(
+                    {"tools": TOOL_TARGETS, "presets": WORKSPACE_PRESETS},
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            return 0
+        target = sub_args[0]
+        pane = sub_args[1] if len(sub_args) > 1 and len(sub_args[1]) == 1 else None
+        res = switcher.switch(target, pane=pane)
+        print(json.dumps(res, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd in ("hud", "window"):
+        wm = HalfScreenWindowManager(config)
+        if "--bench" in sub_args or "bench" in sub_args:
+            print(json.dumps({"runtimes": WINDOW_RUNTIMES_BENCHMARK}, ensure_ascii=False, indent=2))
+            return 0
+        for i, tok in enumerate(sub_args):
+            if tok == "--export-tauri":
+                out_dir = Path(sub_args[i + 1]) if i + 1 < len(sub_args) else (Path.cwd() / "heyasa-tauri-hud")
+                print(json.dumps(wm.export_tauri_v2_scaffold(out_dir), ensure_ascii=False, indent=2))
+                return 0
+        position = "top" if "--top" in sub_args else "bottom"
+        target_app = "willman" if "willman" in sub_args else "willmux"
+        dry = known.dry_run or "--dry-run" in sub_args or "--geometry" in sub_args
+        res = wm.launch_or_toggle(target=target_app, position=position, height_ratio=0.48, dry_run=dry)
+        print(json.dumps(res, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd == "willpad":
+        return _handle_willpad_subcommand(router, sub_args, protocol=protocol, as_json=known.json)
+
+    if subcmd in ("willman", "subactor", "dockuri", "taskand"):
+        query = " ".join(sub_args).strip() or "status"
+        receipt = router.dispatch(
+            query,
+            engine=subcmd,
+            protocol=protocol,
+            autonomy_mode=autonomy,
+            confirmed=confirmed,
+            origin="cli",
+        )
+        _print_receipt(receipt, as_json=known.json)
+        return 0
+
+    if subcmd == "catalog":
+        fmt = "json" if known.json else "table"
+        for i, tok in enumerate(sub_args):
+            if tok in ("--format", "-f") and i + 1 < len(sub_args):
+                fmt = sub_args[i + 1]
+        if fmt == "gbnf":
+            print(router.registry.export_gbnf_grammar(engine))
+            return 0
+        manifest = router.registry.export_nl_api_manifest(engine)
+        if fmt in ("json", "nl-api"):
+            print(json.dumps(manifest, ensure_ascii=False, indent=2))
+        else:
+            print(f"{'ENGINE':<10} {'ACTION URI':<44} {'EFFECT':<8} {'RISK':<7} {'OPIS'}")
+            print("-" * 105)
+            for ep in manifest["endpoints"]:
+                print(
+                    f"{ep['engine']:<10} {ep['native_uri']:<44} {ep['effect']:<8} {ep['risk']:<7} {ep['summary_pl']}"
+                )
+        return 0
+
+    if subcmd == "snapshot":
+        snap = router.snapshot(engine=engine, autonomy=autonomy)
+        print(json.dumps(snap, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd == "receipts":
+        limit = 20
+        items = router.receipt_store.list_receipts(limit=limit, engine=engine)
+        print(json.dumps({"receipts": items}, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd == "gov":
+        action = sub_args[0] if sub_args else "standards"
+        root = Path.cwd()
+        res = run_wellman_governance(action, root=root)
+        print(json.dumps(res, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd == "serve":
+        port = config.rest_port
+        host = config.rest_host
+        for i, tok in enumerate(sub_args):
+            if tok == "--port" and i + 1 < len(sub_args):
+                port = int(sub_args[i + 1])
+            elif tok == "--host" and i + 1 < len(sub_args):
+                host = sub_args[i + 1]
+        return serve_rest(router, host=host, port=port)
+
+    if subcmd == "mcp":
+        if "--manifest" in sub_args or known.json:
+            print(json.dumps(build_mcp_gateway_manifest(router), ensure_ascii=False, indent=2))
+            return 0
+        transport = "streamable-http" if "--http" in sub_args else "stdio"
+        return serve_mcp(router, transport=transport, host=config.rest_host, port=config.mcp_port)
+
+    if subcmd == "grpc":
+        if "--proto" in sub_args:
+            print(HEYASA_PROTO_SPEC)
+            return 0
+        svc = HeyasaGrpcService(router)
+        print(json.dumps({"service": "heyasa.v1.HeyasaService", "port": config.grpc_port, "state": svc.get_state()}, ensure_ascii=False, indent=2))
+        return 0
+
+    if subcmd == "acp":
+        return serve_acp_stdio(router)
+
+    # Free-form natural language sentence or DSL command
+    full_text = " ".join(rest).strip()
+    receipt = router.dispatch(
+        full_text,
+        engine=engine,
+        protocol=protocol,
+        autonomy_mode=autonomy,
+        confirmed=confirmed,
+        origin="cli",
+    )
+    _print_receipt(receipt, as_json=known.json)
+    return 0
+
+
+def _handle_willpad_subcommand(
+    router: HeyasaRouter,
+    sub_args: List[str],
+    *,
+    protocol: str = "auto",
+    as_json: bool = False,
+) -> int:
+    if not sub_args:
+        st = router.willpad.status()
+        print(json.dumps(st, ensure_ascii=False, indent=2))
+        return 0
+
+    verb = sub_args[0].lower()
+    if verb == "focus":
+        pane = sub_args[1].upper() if len(sub_args) > 1 else "A"
+        uri = f"willpad://pane/focus?pane={pane}"
+    elif verb == "style":
+        style = sub_args[1].lower() if len(sub_args) > 1 and sub_args[1].lower() in WILLPAD_STYLES else "quad"
+        uri = f"willpad://menu/style?style={style}"
+    elif verb == "layout":
+        layout = sub_args[1].lower() if len(sub_args) > 1 else "grid"
+        uri = f"willpad://layout/set?layout={layout}"
+    elif verb == "compact":
+        mode = sub_args[1].lower() if len(sub_args) > 1 else "compact"
+        uri = f"willpad://chat/compact?mode={mode}"
+    elif verb == "tool":
+        pane = sub_args[1].upper() if len(sub_args) > 1 else "B"
+        tool = sub_args[2].lower() if len(sub_args) > 2 and sub_args[2].lower() in WILLPAD_TOOLS else "shot"
+        uri = f"willpad://window/tool?pane={pane}&tool={tool}"
+    else:
+        uri = " ".join(sub_args)
+
+    receipt = router.dispatch(
+        uri,
+        engine="willpad",
+        protocol=protocol,
+        autonomy_mode="auto",
+        confirmed=True,
+        origin="cli",
+    )
+    _print_receipt(receipt, as_json=as_json)
+    return 0
+
+
+def _print_receipt(receipt: dict, *, as_json: bool = False) -> None:
+    if as_json:
+        print(json.dumps(receipt, ensure_ascii=False, indent=2))
+        return
+    card = receipt.get("chat_card") or {}
+    print(f"[{receipt['engine']} | {receipt['autonomy_mode']} -> {receipt['post_execution_state']}] {card.get('summary', '')}")
+    print(f"  URI:     {receipt['resolved_action_uri']}")
+    print(f"  Receipt: {receipt['receipt_ref']} ({receipt['process_urn']})")
+    if receipt["status"] == "pending_approval":
+        plan = (receipt.get("result") or {}).get("plan") or {}
+        if plan.get("id"):
+            print(f"  Zatwierdź: heyasa run {plan['id']} --yes")