agentirc-cli 7.4.0__tar.gz → 8.1.0__tar.gz

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [8.1.0] - 2026-04-23
+
+### Added
+
+- `culture afi` namespace — passthrough to the standalone `afi-cli` (Agent First Interface scaffolder) with argparse-REMAINDER argument forwarding, parallel to `culture devex`.
+- Universal verbs register the `afi` topic; `culture explain afi` / `culture overview afi` / `culture learn afi` all route through `afi-cli` 0.3+ and `culture explain` no longer marks `culture afi` as coming-soon.
+- `afi-cli>=0.3,<1.0` as a library dependency (0.3 added the `overview` verb + sixth rubric bundle per agentculture/afi-cli#5).
+- `culture/cli/_passthrough.py` — shared plumbing for `culture <ext>` subcommands that embed a sibling CLI. Supplies `run()`, `capture()`, and `register_topic()` so each passthrough module stays a thin adapter.
+
+### Changed
+
+- `culture/cli/devex.py` refactored onto the new shared passthrough helper. Behaviour is preserved (explain/overview/learn argv and typer app invocation unchanged); the module shrinks to a package-specific entry adapter and a single `register_topic` call. When agex-cli adopts the agent-first CLI contract (`main(argv) -> int`, tracking: agentculture/agex-cli#30), the adapter collapses to a direct delegation.
+
+## [8.0.0] - 2026-04-22
+
+### Added
+
+- `culture afi`, `culture identity`, and `culture secret` surfaced as (coming soon) namespaces in `culture explain` output. `culture identity` will wrap a future standalone `zehut-cli`; `culture secret` will wrap `shushu-cli`; `culture afi` shares its name with the standalone `afi-cli`.
+
+### Changed
+
+- BREAKING: Renamed `culture agex` to `culture devex` (developer experience) — more familiar terminology and visually distinct from `culture agent`. The upstream `agex-cli` / `agent_experience` library is unchanged; only culture's public command name differs.
+- Positioning docs, README, and site chrome refreshed to reflect the new identity: culture is the framework of agreements that makes agent behavior portable, inspectable, and effective, surfacing explain/overview/learn at every CLI level.
+
 ## [7.4.0] - 2026-04-22
 
 ### Added

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 7.4.0
+Version: 8.1.0
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Communications :: Chat :: Internet Relay Chat
 Requires-Python: >=3.12
+Requires-Dist: afi-cli<1.0,>=0.3
 Requires-Dist: agex-cli<1.0,>=0.13
 Requires-Dist: aiohttp>=3.9
 Requires-Dist: anthropic>=0.40
@@ -25,18 +26,23 @@ Description-Content-Type: text/markdown
 
 # Culture
 
-The complete human-agent collaboration system built around AgentIRC.
+The framework of agreements that makes agent behavior portable, inspectable, and effective.
 
 **AgentIRC** is the IRC-native runtime for persistent AI agents and humans in shared live rooms.
-**Culture** is the full solution — CLI, harnesses, console, workflows, and multi-machine mesh.
+**Culture** is the full solution — CLI with universal introspection verbs (`explain` / `overview` / `learn` at every level), harnesses, console, workflows, and multi-machine mesh. It ships `culture devex` today (powered by the standalone `agex-cli`) and will add `culture afi`, `culture identity`, and `culture secret` next.
 
 ## Start here
 
 - [Quickstart](https://culture.dev/quickstart/) — install and start in 5 minutes
 - [Choose a Harness](https://culture.dev/choose-a-harness/) — Claude Code, Codex, Copilot, ACP
+- [`culture devex` and universal verbs](https://culture.dev/reference/cli/devex/) — the inspectable CLI
 - [AgentIRC Architecture](https://culture.dev/agentirc/architecture-overview/) — the runtime layer
 - [Vision & Patterns](https://culture.dev/vision/) — the broader model
 
+## What's next
+
+`culture afi` (Agent First Interface), `culture identity` (mesh identity / key management, wrapping the standalone `zehut-cli`), and `culture secret` (credential management, wrapping `shushu-cli`) are on the way. Run `culture explain` for the always-current registry of what's ready vs. coming soon.
+
 ## Install
 
 ```bash

agentirc_cli-8.1.0/README.md

@@ -0,0 +1,34 @@
+# Culture
+
+The framework of agreements that makes agent behavior portable, inspectable, and effective.
+
+**AgentIRC** is the IRC-native runtime for persistent AI agents and humans in shared live rooms.
+**Culture** is the full solution — CLI with universal introspection verbs (`explain` / `overview` / `learn` at every level), harnesses, console, workflows, and multi-machine mesh. It ships `culture devex` today (powered by the standalone `agex-cli`) and will add `culture afi`, `culture identity`, and `culture secret` next.
+
+## Start here
+
+- [Quickstart](https://culture.dev/quickstart/) — install and start in 5 minutes
+- [Choose a Harness](https://culture.dev/choose-a-harness/) — Claude Code, Codex, Copilot, ACP
+- [`culture devex` and universal verbs](https://culture.dev/reference/cli/devex/) — the inspectable CLI
+- [AgentIRC Architecture](https://culture.dev/agentirc/architecture-overview/) — the runtime layer
+- [Vision & Patterns](https://culture.dev/vision/) — the broader model
+
+## What's next
+
+`culture afi` (Agent First Interface), `culture identity` (mesh identity / key management, wrapping the standalone `zehut-cli`), and `culture secret` (credential management, wrapping `shushu-cli`) are on the way. Run `culture explain` for the always-current registry of what's ready vs. coming soon.
+
+## Install
+
+```bash
+uv tool install culture
+culture server start
+```
+
+## Documentation
+
+- **[culture.dev](https://culture.dev)** — the full solution: quickstart, harnesses, guides, vision
+- **[culture.dev/agentirc](https://culture.dev/agentirc/)** — the runtime layer: architecture, protocol, federation
+
+## License
+
+[MIT](LICENSE)

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/_config.culture.yml

@@ -1,6 +1,6 @@
 title: Culture
 description: >-
-  The professional workspace for agents.
+  The framework of agreements that makes agent behavior portable, inspectable, and effective — a professional workspace for agents with a CLI that explains itself.
 url: "https://culture.dev"
 baseurl: ""
 build_site: culture
@@ -12,7 +12,7 @@ twitter:
 social:
   name: Culture
   links:
-    - https://github.com/OriNachum/culture
+    - https://github.com/agentculture/culture
 
 author:
   name: Ori Nachum
@@ -39,13 +39,15 @@ aux_links:
   "Citation CLI":
     - "/citation-cli/"
   "GitHub":
-    - "https://github.com/OriNachum/culture"
+    - "https://github.com/agentculture/culture"
 
 aux_links_new_tab: false
 
 footer_content: >-
   Culture — human-agent collaboration built around
   <a href="/agentirc/">AgentIRC</a>.
+  Inspectable CLI via <a href="/reference/cli/devex/">culture devex</a>
+  (explain / overview / learn at every level).
   Agent Experience via <a href="https://culture.dev/agex/">agex-cli</a>.
   Code distribution via <a href="/citation-cli/">Citation CLI</a>.
-  Source on <a href="https://github.com/OriNachum/culture">GitHub</a>.
+  Source on <a href="https://github.com/agentculture/culture">GitHub</a>.

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/culture/cli/__init__.py

@@ -7,7 +7,8 @@ Commands are organized into noun-based groups:
     culture channel  {list,read,message,who}
     culture bot      {create,start,stop,list,inspect,archive,unarchive}
     culture skills   {install}
-    culture agex     {...full passthrough to the standalone `agex` CLI...}
+    culture devex    {...developer-experience passthrough (powered by agex-cli)...}
+    culture afi      {...agent-first interface passthrough (powered by afi-cli)...}
 
 Universal verbs (available at the root):
     culture explain [topic]    full description of topic (default: culture)
@@ -22,9 +23,9 @@ import logging
 import sys
 
 from culture import __version__
-from culture.cli import agent, agex, bot, channel, introspect, mesh, server, skills
+from culture.cli import afi, agent, bot, channel, devex, introspect, mesh, server, skills
 
-GROUPS = [agent, server, mesh, channel, bot, skills, agex, introspect]
+GROUPS = [agent, server, mesh, channel, bot, skills, devex, afi, introspect]
 
 
 def _names_of(group) -> set[str]:

agentirc_cli-8.1.0/culture/cli/_passthrough.py

@@ -0,0 +1,116 @@
+"""Shared plumbing for `culture <ext>` passthrough subcommands.
+
+A passthrough module (e.g. ``culture devex``, ``culture afi``) embeds a
+sibling CLI in-process: arguments after the namespace token are forwarded
+verbatim to the external CLI's entry callable, and the three universal
+verbs (``explain`` / ``overview`` / ``learn``) capture the external CLI's
+output and route it through :mod:`culture.cli.introspect`.
+
+Each passthrough module supplies a package-specific ``Entry`` callable
+with signature ``(argv: list[str]) -> int | None``. The callable may:
+
+* return ``None`` or ``0`` for success,
+* return a non-zero ``int`` for a handled error,
+* raise ``SystemExit`` for argparse ``--help`` / ``--version`` / errors
+  or typer's standalone-mode hard-exit on completion.
+
+:func:`run` propagates via ``sys.exit`` (for the ``dispatch()`` path).
+:func:`capture` collects stdout+stderr and translates ``SystemExit`` into
+an ``int`` return code (for the universal-verb handlers, which must
+return ``(stdout, rc)``).
+
+The long-term target is every embedded CLI exposing a clean
+``main(argv) -> int`` (agent-first CLI contract owned by afi-cli). Until
+then, typer-backed CLIs like agex-cli can be wrapped in a small entry
+adapter that calls the typer ``app`` — the plumbing here stays unchanged.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import sys
+from typing import Callable
+
+from culture.cli import introspect
+
+Entry = Callable[[list[str]], "int | None"]
+
+
+def _translate_exit(code: "int | str | None") -> "tuple[int, str | None]":
+    """Map a ``SystemExit.code`` to ``(rc, message)``.
+
+    Python's ``sys.exit`` accepts ``None`` (rc 0), an ``int`` (rc = int), or
+    anything else (rc 1 with the stringified value printed to stderr). We
+    mirror all three so an embedded CLI using any ``sys.exit`` form is
+    surfaced to culture's caller the way a bare invocation would be.
+    """
+    if code is None:
+        return 0, None
+    if isinstance(code, int):
+        return code, None
+    return 1, str(code)
+
+
+def run(entry: Entry, argv: list[str]) -> None:
+    """Invoke ``entry(argv)`` and ``sys.exit`` with its return code.
+
+    Used by a group module's ``dispatch()`` to forward arguments verbatim to
+    the embedded CLI. ``SystemExit`` raised inside the entry (typer's
+    hard-exit, argparse's ``--help`` / ``--version`` / error path, or
+    ``sys.exit("msg")``) is caught, its message (if any) forwarded to
+    stderr, and its code re-emitted via ``sys.exit`` so the behaviour
+    matches a bare invocation of the embedded CLI.
+    """
+    try:
+        rc = entry(argv) or 0
+    except SystemExit as exc:  # NOSONAR S5754 — SystemExit is re-emitted via sys.exit below
+        rc, message = _translate_exit(exc.code)
+        if message is not None:
+            print(message, file=sys.stderr)
+    sys.exit(rc)
+
+
+def capture(entry: Entry, argv: list[str]) -> tuple[str, int]:
+    """Invoke ``entry(argv)`` with stdout+stderr captured; return ``(out, rc)``.
+
+    Used by universal-verb handlers (``explain`` / ``overview`` / ``learn``),
+    which must return a value rather than exit. ``SystemExit`` raised inside
+    the entry is translated into the ``rc`` half of the return tuple; any
+    string-valued ``exc.code`` is appended to the captured buffer so the
+    embedded CLI's error text reaches the caller the way a bare invocation
+    would emit it on stderr.
+    """
+    buf = io.StringIO()
+    rc = 0
+    try:
+        with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
+            rc = entry(argv) or 0
+    except SystemExit as exc:  # NOSONAR S5754 — code is surfaced as rc; behaviour documented above
+        rc, message = _translate_exit(exc.code)
+        if message is not None:
+            buf.write(message)
+            if not message.endswith("\n"):
+                buf.write("\n")
+    return buf.getvalue(), rc
+
+
+def register_topic(
+    topic: str,
+    entry: Entry,
+    *,
+    explain_argv: list[str],
+    overview_argv: list[str],
+    learn_argv: list[str],
+) -> None:
+    """Register ``explain`` / ``overview`` / ``learn`` handlers for ``topic``.
+
+    Each handler captures the output of ``entry(<verb_argv>)`` and returns
+    ``(stdout, rc)`` per the :mod:`culture.cli.introspect` handler protocol.
+    """
+    introspect.register_topic(
+        topic,
+        explain=lambda _t: capture(entry, explain_argv),
+        overview=lambda _t: capture(entry, overview_argv),
+        learn=lambda _t: capture(entry, learn_argv),
+    )

agentirc_cli-8.1.0/culture/cli/afi.py

@@ -0,0 +1,71 @@
+"""`culture afi` — passthrough to the standalone afi CLI.
+
+afi (Agent First Interface) scaffolds and audits agent-first CLIs, MCP
+servers, and HTTP sites. Culture embeds it as a first-class namespace so
+the culture CLI exposes the same agent-first affordances afi enforces.
+
+This module is a thin adapter: it supplies a package-specific ``Entry``
+callable and wires the three universal verbs
+(``explain`` / ``overview`` / ``learn``) through
+:mod:`culture.cli._passthrough`. afi already implements the agent-first
+CLI contract (``main(argv) -> int``), so the entry is a direct
+delegation — no typer adapter needed.
+
+``afi-cli`` owns the rubric the contract is measured against. See
+`agentculture/afi-cli#5 <https://github.com/agentculture/afi-cli/issues/5>`_
+for the tracking issue that adds an ``overview`` verb + rubric bundle so
+afi models every check it enforces.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from culture.cli import _passthrough
+
+NAME = "afi"
+
+
+def _entry(argv: list[str]) -> "int | None":
+    """In-process call into ``afi.cli.main(argv)``.
+
+    afi's ``main`` returns an ``int`` on normal completion and raises
+    ``SystemExit`` only for argparse-level exits (``--help``, ``--version``,
+    unknown flag). Both paths are handled by :mod:`culture.cli._passthrough`.
+    """
+    try:
+        from afi.cli import main
+    except ImportError as exc:  # pragma: no cover — declared dep
+        print(f"afi-cli is not installed: {exc}", file=sys.stderr)
+        sys.exit(2)
+    return main(argv)
+
+
+_passthrough.register_topic(
+    "afi",
+    _entry,
+    explain_argv=["explain"],
+    overview_argv=["overview"],
+    learn_argv=["learn"],
+)
+
+
+# --- CLI group protocol ---------------------------------------------------
+
+
+def register(subparsers: "argparse._SubParsersAction") -> None:
+    # prefix_chars=chr(0): every token (including --help, --version) is
+    # treated as positional and captured in afi_args for the underlying
+    # afi argparse parser to handle.
+    p = subparsers.add_parser(
+        NAME,
+        help="Run the afi agent-first CLI via passthrough",
+        add_help=False,
+        prefix_chars=chr(0),
+    )
+    p.add_argument("afi_args", nargs=argparse.REMAINDER, help="Arguments passed to afi")
+
+
+def dispatch(args: argparse.Namespace) -> None:
+    _passthrough.run(_entry, list(getattr(args, "afi_args", []) or []))

agentirc_cli-8.1.0/culture/cli/devex.py

@@ -0,0 +1,71 @@
+"""`culture devex` — passthrough to the standalone agex CLI.
+
+Under the hood, ``devex`` is powered by the standalone ``agex-cli``
+(``agent_experience`` package). The command name differs for familiarity
+with the developer-experience vocabulary; the underlying tool is the
+same.
+
+This module is a thin adapter: it supplies a package-specific ``Entry``
+callable and wires the three universal verbs
+(``explain`` / ``overview`` / ``learn``) through
+:mod:`culture.cli._passthrough`. When agex-cli migrates to the
+agent-first CLI contract (``main(argv) -> int``), the adapter becomes a
+one-line ``return main(argv)`` without touching the shared plumbing.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from culture.cli import _passthrough
+
+NAME = "devex"
+
+
+def _entry(argv: list[str]) -> None:
+    """In-process call into the agex typer ``app``.
+
+    Typer's default ``standalone_mode=True`` makes ``app`` call ``sys.exit``
+    when it finishes — so this function naturally raises ``SystemExit``,
+    which :mod:`culture.cli._passthrough` translates into an ``int`` for the
+    universal-verb handlers and re-emits via ``sys.exit`` for the direct
+    passthrough path.
+    """
+    try:
+        from agent_experience.cli import app
+    except ImportError as exc:  # pragma: no cover — declared dep
+        print(f"agex-cli is not installed: {exc}", file=sys.stderr)
+        sys.exit(2)
+    app(args=argv)
+
+
+# The underlying agex library refers to itself as "agex"; we pass that to
+# its own explain verb. The culture-facing name is devex.
+_passthrough.register_topic(
+    "devex",
+    _entry,
+    explain_argv=["explain", "agex"],
+    overview_argv=["overview", "--agent", "claude-code"],
+    learn_argv=["learn", "--agent", "claude-code"],
+)
+
+
+# --- CLI group protocol ---------------------------------------------------
+
+
+def register(subparsers: "argparse._SubParsersAction") -> None:
+    # prefix_chars=chr(0) means the devex subparser has no recognized flag
+    # prefix character, so every token (including --help, --version) is
+    # treated as positional and captured in devex_args for typer to handle.
+    p = subparsers.add_parser(
+        NAME,
+        help="Run the agex developer-experience CLI via passthrough",
+        add_help=False,
+        prefix_chars=chr(0),
+    )
+    p.add_argument("devex_args", nargs=argparse.REMAINDER, help="Arguments passed to agex")
+
+
+def dispatch(args: argparse.Namespace) -> None:
+    _passthrough.run(_entry, list(getattr(args, "devex_args", []) or []))

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/culture/cli/introspect.py

@@ -68,6 +68,18 @@ def _resolve(verb: str, topic: str | None) -> tuple[str, int]:
     effective = topic if topic is not None else "culture"
     handler = registry.get(effective)
     if handler is None:
+        # Known-but-unregistered namespaces are advertised via _NAMESPACES
+        # in `culture explain` output with "(coming soon)". Surface that
+        # same framing on a direct `culture <verb> <ns>` call instead of
+        # failing as if the topic were unknown. Exit 0 because this is a
+        # known future state, not a user error.
+        if effective in _NAMESPACES:
+            return (
+                f"`culture {effective}` — coming soon. "
+                f"Not yet implemented. Run `culture explain` to see the "
+                f"current registry of namespaces.\n",
+                0,
+            )
         available = sorted(registry.keys())
         msg = (
             f"unknown topic '{effective}' for {verb};"
@@ -89,7 +101,18 @@ def learn(topic: str | None) -> tuple[str, int]:
     return _resolve("learn", topic)
 
 
-_NAMESPACES = ("agex", "server", "agent", "mesh", "bot", "channel", "skills")
+_NAMESPACES = (
+    "agent",
+    "server",
+    "mesh",
+    "channel",
+    "bot",
+    "skills",
+    "devex",
+    "afi",
+    "identity",
+    "secret",
+)
 
 
 def _culture_explain(_topic: str | None) -> tuple[str, int]:

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/docs/culture/features.md

@@ -70,6 +70,21 @@ description: Everything in the workspace — grouped by who it's for.
   <a class="feature-group-deep" href="{{ '/agentirc/architecture-overview/' | relative_url }}">Under the hood → AgentIRC</a>
 </div>
 
+<div class="feature-group">
+  <div class="feature-group-head">
+    <span class="feature-group-kicker">05</span>
+    <span class="feature-group-title">Introspection &amp; experience</span>
+  </div>
+  <p class="feature-group-desc">The CLI explains itself. Each namespace owns its own docs.</p>
+  <div class="feature-group-items">
+    <div>culture explain / overview / learn</div>
+    <div>culture devex (powered by agex-cli)</div>
+    <div>culture afi (powered by afi-cli)</div>
+    <div>culture identity / secret (coming soon)</div>
+  </div>
+  <a class="feature-group-deep" href="{{ '/reference/cli/devex/' | relative_url }}">Read the contract →</a>
+</div>
+
 <div class="callout-relationship">
   <p><strong>Want the runtime internals?</strong> AgentIRC is the IRC-native server at the core. <a href="{{ '/agentirc/' | relative_url }}">Explore AgentIRC →</a></p>
 </div>

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/docs/culture/index.md

@@ -9,7 +9,7 @@ description: The professional workspace for agents.
 <div class="hero">
   <p class="hero-label">The professional workspace for agents</p>
   <h1 class="hero-headline">Where your agents actually&nbsp;work.</h1>
-  <p class="hero-sub">Persistent rooms. Real colleagues. One CLI. Multi-machine mesh.</p>
+  <p class="hero-sub">Persistent rooms. Real colleagues. A CLI that explains itself. Multi-machine mesh.</p>
   <div>
     <a href="{{ '/quickstart/' | relative_url }}" class="btn-cta btn-cta--primary">Quickstart</a>
     <a href="{{ '/features/' | relative_url }}" class="btn-cta btn-cta--secondary">See the workspace</a>
@@ -28,7 +28,7 @@ description: The professional workspace for agents.
   <div class="stack-row">
     <span class="stack-row-label">You</span>
     <div class="stack-row-content">
-      <strong>Culture CLI</strong> <span class="text-muted">uv tool install culture</span>
+      <strong>Culture CLI</strong> <span class="text-muted">uv tool install culture · explain · overview · learn at every level</span>
     </div>
   </div>
   <div class="stack-row">
@@ -76,6 +76,10 @@ description: The professional workspace for agents.
     <p class="docs-card-title">Join as a Human</p>
     <p class="docs-card-desc">Console or any IRC client</p>
   </a>
+  <a href="{{ '/reference/cli/devex/' | relative_url }}" class="docs-card">
+    <p class="docs-card-title">Inspectable CLI</p>
+    <p class="docs-card-desc">culture explain · overview · learn · devex</p>
+  </a>
 </div>
 
 <div class="callout-relationship">

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/docs/culture/mental-model.md

@@ -49,6 +49,21 @@ This is the Reflective Development paradigm: the system is self-improving becaus
 the participants — both human and AI — have access to the same context and the
 same tools.
 
+Reflection is also built into the CLI itself through three **universal verbs**
+available at every level of the command tree:
+
+- `explain X` — deep description of X and everything under X.
+- `overview X` — shallow map of X.
+- `learn X` — agent-facing onboarding prompt for operating X, so an agent
+  doesn't have to re-explore X every time it connects.
+
+Each namespace owns its own handlers — `culture` is pure plumbing. An agent
+can run `culture explain`, `culture explain devex`, `culture overview mesh`,
+or `culture learn agent` and get progressively-scoped self-description
+without leaving the shell. See the
+[`culture devex` reference]({{ '/reference/cli/devex/' | relative_url }})
+for the contract and the current registry of topics.
+
 ## Organization
 
 Multiple Culture instances link together through federation. Each instance is

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/docs/culture/vision.md

@@ -60,3 +60,26 @@ read and write plain text, which is what language models are built to do.
 The protocol handles presence, channels, messaging, and federation.
 Culture extends it with attention routing, skills, and agent lifecycle
 management — but the foundation is standard IRC.
+
+## Upcoming
+
+Culture is the framework of agreements that makes agent behavior portable,
+inspectable, and effective. Beyond the workspace runtime and the two
+first-class passthrough namespaces that already ship —
+[`culture devex`]({{ '/reference/cli/devex/' | relative_url }}) (powered
+by `agex-cli`) and
+[`culture afi`]({{ '/reference/cli/afi/' | relative_url }}) (powered by
+the standalone `afi-cli`, the Agent First Interface scaffolder) — two
+more first-class namespaces are next:
+
+- **`culture identity`** — Identity management across the mesh. Wraps a
+  standalone `zehut-cli` (Hebrew: "identity"). The command you'll reach
+  for to name agents, issue keys, and federate trust between servers.
+- **`culture secret`** — Secret management. Wraps a standalone
+  `shushu-cli`. Handles credentials and sensitive config for agents and
+  harnesses.
+
+Culture uses English for its first-class nouns; the standalone CLIs keep
+their brand names. You don't have to remember which is which —
+`culture explain` is the always-current source of truth and lists each
+namespace's current state (registered vs. coming soon) at runtime.

{agentirc_cli-7.4.0 → agentirc_cli-8.1.0}/docs/culture/what-is-culture.md

@@ -3,7 +3,7 @@ title: "What is Culture?"
 parent: "Vision & Patterns"
 nav_order: 1
 sites: [culture]
-description: Culture is a professional workspace for specialized agents. Here's what that means.
+description: Culture is the framework that makes agent behavior portable, inspectable, and effective — a professional workspace for specialized agents.
 permalink: /what-is-culture/
 redirect_from:
   - /why-culture/
@@ -11,12 +11,14 @@ redirect_from:
 
 # What is Culture?
 
-Culture is a professional workspace for specialized agents. Through AgentIRC,
-it provides the shared environment — rooms, presence, roles, coordination,
-and history that persists across sessions — where agents and humans work
-together. Harnesses are optional connectors: they let an agent stay present
-in the culture without being pushed to read every message, so participating
-in the workspace doesn't mean drowning in it.
+Culture is the framework of agreements that makes agent behavior portable,
+inspectable, and effective. Concretely, it provides two things: a shared
+professional workspace for specialized agents (rooms, presence, roles,
+coordination, and history via AgentIRC), and a CLI whose every level
+explains itself so agents can operate the system without re-discovering it
+each session. Harnesses are optional connectors: they let an agent stay
+present in the culture without being pushed to read every message, so
+participating in the workspace doesn't mean drowning in it.
 
 ## A professional workspace for specialized agents
 
@@ -47,6 +49,25 @@ Teachability is real and important — but it is not what sets Culture apart.
 What sets Culture apart is the shared professional workspace of specialized
 agents.
 
+## Inspectable from any level
+
+Culture ships three **universal verbs** — `explain`, `overview`, and
+`learn` — available at every level of the CLI command tree, each scoped
+to that node and its descendants:
+
+- `culture explain [topic]` — full description (deep).
+- `culture overview [topic]` — shallow map.
+- `culture learn [topic]` — agent-facing onboarding prompt so an agent
+  can operate the topic without re-exploring it each session.
+
+Each namespace owns its own handlers — culture is pure plumbing. Today
+the [`culture devex`]({{ '/reference/cli/devex/' | relative_url }})
+namespace (powered by `agex-cli`) and the
+[`culture afi`]({{ '/reference/cli/afi/' | relative_url }}) namespace
+(powered by `afi-cli`) are registered; `culture identity` and
+`culture secret` remain `(coming soon)` and will be added in future
+releases following the same pattern.
+
 ## Reference points
 
 Systems like OpenClaw are useful reference points because they focus on the
@@ -69,3 +90,4 @@ not a replacement for what they already carry.
 - For the broader model and where this is going → [Vision]({{ '/vision/' | relative_url }}).
 - For the conceptual model (spaces, membership, reflection) → [Mental model]({{ '/mental-model/' | relative_url }}).
 - For the capability list → [Features]({{ '/features/' | relative_url }}).
+- For the CLI's self-explaining surface → [`culture devex` and universal verbs]({{ '/reference/cli/devex/' | relative_url }}).