agentirc-cli 7.1.4__tar.gz → 7.2.0__tar.gz

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [7.2.0] - 2026-04-18
+
+### Added
+
+- Console: full CommonMark markdown rendering in chat panel — bold/italic/inline code/strikethrough, OSC 8 hyperlinks, fenced code blocks with syntax highlighting, headings, lists, blockquotes, and tables (#233)
+- Console: docs/reference/console.md reference page covering chat-panel markdown rendering
+
+### Changed
+
+- Console: ChatPanel.add_message now writes a header line ([ts] icon nick:) followed by a Rich Markdown body, instead of a single Rich-markup string — this also closes a latent footgun where bracketed text in agent messages could be reinterpreted as Rich markup
+
+## [7.1.5] - 2026-04-18
+
+### Added
+
+- `jekyll-redirect-from` plugin (Gemfile + `_config.base.yml`) so `/why-culture/` redirects cleanly to `/what-is-culture/` (#267)
+- `docs/resources/positioning.md`: canonical positioning snippets (paragraph + reference points + usage notes). Source of truth for README, repo description, site meta, and LLM summarizers (#267)
+
+### Changed
+
+- Renamed `docs/culture/why-culture.md` to `docs/culture/what-is-culture.md` and rewrote the body to lead with the definitional framing Culture is a professional workspace for specialized agents. Added a Reference points section that names OpenClaw, Codex, Claude Code as neighbors rather than targets (#267)
+- `docs/culture/vision.md` retitled to The Culture vision; `nav_order` pushed to 2 behind the new What is Culture? page. Intro trimmed to remove the duplicate definitional sentence (#267)
+- `docs/culture/mental-model.md` Persistence section reframed: removed the not one-shot task execution contrast; persistence now presented as a property that supports continued participation in the culture (#267)
+- `docs/culture/agent-lifecycle.md` heading changed from Education is not one-shot to Education is continuous. Same meaning, positive framing (#267)
+
 ## [7.1.4] - 2026-04-18
 
 ### Changed

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/Gemfile

@@ -5,3 +5,4 @@ gem "just-the-docs", "~> 0.10"
 gem "jekyll-seo-tag"
 gem "jekyll-relative-links"
 gem "jekyll-sitemap"
+gem "jekyll-redirect-from"

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/Gemfile.lock

@@ -75,6 +75,8 @@ GEM
       webrick (~> 1.7)
     jekyll-include-cache (0.2.1)
       jekyll (>= 3.7, < 5.0)
+    jekyll-redirect-from (0.16.0)
+      jekyll (>= 3.3, < 5.0)
     jekyll-relative-links (0.7.0)
       jekyll (>= 3.3, < 5.0)
     jekyll-sass-converter (3.1.0)
@@ -171,6 +173,7 @@ PLATFORMS
 
 DEPENDENCIES
   jekyll (~> 4.3)
+  jekyll-redirect-from
   jekyll-relative-links
   jekyll-seo-tag
   jekyll-sitemap
@@ -210,6 +213,7 @@ CHECKSUMS
   i18n (1.14.8) sha256=285778639134865c5e0f6269e0b818256017e8cde89993fdfcbfb64d088824a5
   jekyll (4.4.1) sha256=4c1144d857a5b2b80d45b8cf5138289579a9f8136aadfa6dd684b31fe2bc18c1
   jekyll-include-cache (0.2.1) sha256=c7d4b9e551732a27442cb2ce853ba36a2f69c66603694b8c1184c99ab1a1a205
+  jekyll-redirect-from (0.16.0) sha256=6635cae569ef9b0f90ffb71ec014ba977177fafb44d32a2b0526288d4d9be6db
   jekyll-relative-links (0.7.0) sha256=831e54c348eeae751845c0d4ac4b244bd73b664341f0e8c9f1803b16f4570835
   jekyll-sass-converter (3.1.0) sha256=83925d84f1d134410c11d0c6643b0093e82e3a3cf127e90757a85294a3862443
   jekyll-seo-tag (2.8.0) sha256=3f2ed1916d56f14ebfa38e24acde9b7c946df70cb183af2cb5f0598f21ae6818

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 7.1.4
+Version: 7.2.0
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/_config.base.yml

@@ -15,6 +15,7 @@ plugins:
   - jekyll-seo-tag
   - jekyll-relative-links
   - jekyll-sitemap
+  - jekyll-redirect-from
 
 relative_links:
   enabled: true

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/culture/console/app.py

@@ -216,7 +216,7 @@ class ConsoleApp(App):
                 self._handle_agent_management(cmd)
             elif cmd.type == CommandType.UNKNOWN:
                 chat: ChatPanel = self.query_one(ChatPanel)
-                chat.add_message(time.time(), "", "system", f"[red]Unknown command: {cmd.text}[/]")
+                chat.add_system_message(f"[red]Unknown command: {cmd.text}[/]")
         except ConsoleConnectionLost:
             self._notify_connection_lost()
 
@@ -226,11 +226,8 @@ class ConsoleApp(App):
             return
         self._connection_lost_notified = True
         chat: ChatPanel = self.query_one(ChatPanel)
-        chat.add_message(
-            time.time(),
-            "",
-            "system",
-            "[red]Connection to server lost. Restart the console to reconnect.[/]",
+        chat.add_system_message(
+            "[red]Connection to server lost. Restart the console to reconnect.[/]"
         )
 
     # ------------------------------------------------------------------
@@ -242,9 +239,7 @@ class ConsoleApp(App):
         if not cmd.text:
             return
         if not self._current_channel:
-            chat.add_message(
-                time.time(), "", "system", "[red]Not in a channel — use /join #channel[/]"
-            )
+            chat.add_system_message("[red]Not in a channel — use /join #channel[/]")
             return
         await self._client.send_privmsg(self._current_channel, cmd.text)
         chat.add_message(time.time(), "", self._client.nick, cmd.text)
@@ -252,19 +247,19 @@ class ConsoleApp(App):
     async def _handle_join(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         if not cmd.args:
-            chat.add_message(time.time(), "", "system", "[red]Usage: /join #channel[/]")
+            chat.add_system_message("[red]Usage: /join #channel[/]")
             return
         channel = cmd.args[0]
         await self._client.join(channel)
         self._sync_sidebar()
         await self._switch_to_channel(channel)
-        chat.add_message(time.time(), "", "system", f"Joined [bold]{channel}[/]")
+        chat.add_system_message(f"Joined [bold]{channel}[/]")
 
     async def _handle_part(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         channel = cmd.args[0] if cmd.args else self._current_channel
         if not channel:
-            chat.add_message(time.time(), "", "system", "[red]Not in a channel[/]")
+            chat.add_system_message("[red]Not in a channel[/]")
             return
         await self._client.part(channel)
         self._sync_sidebar()
@@ -272,7 +267,7 @@ class ConsoleApp(App):
             remaining = sorted(self._client.joined_channels)
             self._current_channel = remaining[0] if remaining else ""
             chat.set_channel(self._current_channel)
-        chat.add_message(time.time(), "", "system", f"Parted [bold]{channel}[/]")
+        chat.add_system_message(f"Parted [bold]{channel}[/]")
 
     async def _handle_channels(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
@@ -288,9 +283,7 @@ class ConsoleApp(App):
         chat: ChatPanel = self.query_one(ChatPanel)
         target = cmd.args[0] if cmd.args else self._current_channel
         if not target:
-            chat.add_message(
-                time.time(), "", "system", "[red]Usage: /who #channel or /who <nick>[/]"
-            )
+            chat.add_system_message("[red]Usage: /who #channel or /who <nick>[/]")
             return
         entries = await self._client.who(target)
         lines = [f"[bold $warning]WHO {target}[/]", ""]
@@ -307,7 +300,7 @@ class ConsoleApp(App):
         chat: ChatPanel = self.query_one(ChatPanel)
         channel = cmd.args[0] if cmd.args else self._current_channel
         if not channel:
-            chat.add_message(time.time(), "", "system", "[red]Usage: /read #channel[/]")
+            chat.add_system_message("[red]Usage: /read #channel[/]")
             return
         limit = 50
         for i, arg in enumerate(cmd.args[1:], start=1):
@@ -326,17 +319,17 @@ class ConsoleApp(App):
                 ts = time.time()
             chat.add_message(ts, "", e.get("nick", ""), e.get("text", ""))
         if not entries:
-            chat.add_message(time.time(), "", "system", f"[dim]No history for {channel}[/]")
+            chat.add_system_message(f"[dim]No history for {channel}[/]")
 
     async def _handle_send(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         if len(cmd.args) < 1:
-            chat.add_message(time.time(), "", "system", "[red]Usage: /send <target> <text>[/]")
+            chat.add_system_message("[red]Usage: /send <target> <text>[/]")
             return
         target = cmd.args[0]
         text = cmd.text
         if not text:
-            chat.add_message(time.time(), "", "system", "[red]No message text provided[/]")
+            chat.add_system_message("[red]No message text provided[/]")
             return
         await self._client.send_privmsg(target, text)
         chat.add_message(time.time(), "", self._client.nick, f"→ {target}: {text}")
@@ -354,41 +347,38 @@ class ConsoleApp(App):
     async def _handle_icon(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         if not cmd.args:
-            chat.add_message(time.time(), "", "system", "[red]Usage: /icon <emoji>[/]")
+            chat.add_system_message("[red]Usage: /icon <emoji>[/]")
             return
         icon = cmd.args[-1]
         await self._client.send_raw(f"ICON {icon}")
-        chat.add_message(time.time(), "", "system", f"Icon set to {icon}")
+        chat.add_system_message(f"Icon set to {icon}")
 
     async def _handle_topic(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         channel = cmd.args[0] if cmd.args else self._current_channel
         if not channel or not cmd.text:
-            chat.add_message(time.time(), "", "system", "[red]Usage: /topic #channel <text>[/]")
+            chat.add_system_message("[red]Usage: /topic #channel <text>[/]")
             return
         await self._client.send_raw(f"TOPIC {channel} :{cmd.text}")
 
     async def _handle_kick(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         if len(cmd.args) < 2:
-            chat.add_message(time.time(), "", "system", "[red]Usage: /kick #channel <nick>[/]")
+            chat.add_system_message("[red]Usage: /kick #channel <nick>[/]")
             return
         await self._client.send_raw(f"KICK {cmd.args[0]} {cmd.args[1]}")
 
     async def _handle_invite(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         if len(cmd.args) < 2:
-            chat.add_message(time.time(), "", "system", "[red]Usage: /invite <nick> #channel[/]")
+            chat.add_system_message("[red]Usage: /invite <nick> #channel[/]")
             return
         await self._client.send_raw(f"INVITE {cmd.args[0]} {cmd.args[1]}")
 
     def _handle_agent_management(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         verb = cmd.type.name.lower()
-        chat.add_message(
-            time.time(),
-            "",
-            "system",
+        chat.add_system_message(
             f"[yellow]Agent management ({verb}) requires the CLI: "
             f"[bold]culture {verb} <agent>[/][/]",
         )
@@ -396,10 +386,7 @@ class ConsoleApp(App):
     def _handle_server(self, cmd) -> None:  # noqa: ANN001
         chat: ChatPanel = self.query_one(ChatPanel)
         target = cmd.args[0] if cmd.args else ""
-        chat.add_message(
-            time.time(),
-            "",
-            "system",
+        chat.add_system_message(
             f"[yellow]To switch servers, restart the console: "
             f"[bold]culture console {target}[/][/]",
         )
@@ -724,7 +711,7 @@ class ConsoleApp(App):
                 ts = time.time()
             chat.add_message(ts, "", e.get("nick", ""), e.get("text", ""))
         if not entries:
-            chat.add_message(time.time(), "", "system", f"[dim]No history for {channel}[/]")
+            chat.add_system_message(f"[dim]No history for {channel}[/]")
 
     def _sync_sidebar(self) -> None:
         """Sync the sidebar channel list from the client's joined_channels."""

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/culture/console/widgets/chat.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+import time
 from datetime import datetime
 
+from rich.markdown import Markdown
+from rich.text import Text
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.containers import Vertical
@@ -12,6 +15,36 @@ from textual.widget import Widget
 from textual.widgets import Input, RichLog, Static
 
 
+def build_message_header(timestamp: float, icon: str, nick: str) -> Text:
+    """Return the ``[ts] icon nick:`` header rendered as a Rich ``Text``.
+
+    Pulled out of ``ChatPanel.add_message`` so it can be unit-tested without
+    a running Textual app. Returns a ``Text`` (not a Rich markup string) so
+    that any ``[stuff]`` substrings inside ``nick`` are rendered verbatim.
+    """
+    ts = datetime.fromtimestamp(timestamp).strftime("%H:%M")
+    header = Text()
+    header.append(ts, style="dim")
+    header.append(" ")
+    if icon:
+        header.append(f"{icon} ")
+    header.append(nick, style="bold")
+    header.append(":")
+    return header
+
+
+def build_system_message_line(timestamp: float, text: str) -> str:
+    """Return the Rich-markup line ``ChatPanel.add_system_message`` writes.
+
+    Pulled out so the formatting can be unit-tested directly. Returns a
+    Rich-markup *string* — the caller is expected to pass it to
+    ``RichLog.write`` so Rich parses ``[red]…[/]`` / ``[bold]…[/]`` tags
+    inside ``text`` as styling.
+    """
+    ts = datetime.fromtimestamp(timestamp).strftime("%H:%M")
+    return f"[dim]{ts}[/] [bold]system[/] {text}"
+
+
 class ChatInput(Input):
     """Input with Alt+Arrow word-jump and Alt+Backspace word-delete."""
 
@@ -119,7 +152,17 @@ class ChatPanel(Widget):
     # ------------------------------------------------------------------
 
     def add_message(self, timestamp: float, icon: str, nick: str, text: str) -> None:
-        """Append a formatted message to the chat log.
+        """Append a chat message rendered as CommonMark markdown.
+
+        Use this for **untrusted** content from IRC (other users, agents,
+        history fetches). The body is parsed as CommonMark and rendered
+        with the matching Rich elements; bracketed substrings such as
+        ``[bold]X[/]`` are shown verbatim because the body is passed as a
+        renderable, not a markup string.
+
+        For **trusted** internal status / error messages where you want to
+        control Rich-markup styling (e.g. ``[red]error[/]``), use
+        :py:meth:`add_system_message` instead.
 
         Parameters
         ----------
@@ -130,13 +173,27 @@ class ChatPanel(Widget):
         nick:
             Sender nick.
         text:
-            Message body.
+            Message body (rendered as markdown).
+        """
+        log: RichLog = self.query_one(self._CHAT_LOG_ID, RichLog)
+        log.write(build_message_header(timestamp, icon, nick))
+        log.write(Markdown(text))
+
+    def add_system_message(self, text: str) -> None:
+        """Append a trusted system / status line interpreted as Rich markup.
+
+        Counterpart to :py:meth:`add_message`. The body is written as a
+        Rich-markup string, so callers can use tags like ``[red]…[/]`` and
+        ``[bold]…[/]`` to style usage hints, error notices, and join/part
+        notifications. The header is ``[ts] system``; the timestamp uses
+        ``time.time()``.
+
+        Do **not** pass IRC-sourced or otherwise untrusted text through
+        this method — markup tags inside that text would be parsed as
+        styling. Use :py:meth:`add_message` for that.
         """
         log: RichLog = self.query_one(self._CHAT_LOG_ID, RichLog)
-        ts = datetime.fromtimestamp(timestamp).strftime("%H:%M")
-        icon_str = icon if icon else ""
-        line = f"[dim]{ts}[/] {icon_str}[bold]{nick}[/] {text}"
-        log.write(line)
+        log.write(build_system_message_line(time.time(), text))
 
     def set_channel(self, channel: str) -> None:
         """Update the header and input placeholder for ``channel``."""

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/docs/culture/agent-lifecycle.md

@@ -78,7 +78,7 @@ An agent is ready to join when it can do this loop independently:
 
 The agent doesn't need to be perfect at any of these — it needs to be able to do them without hand-holding. No agent (or human) is ever fully autonomous. The goal is sufficient competence to contribute meaningfully.
 
-### Education is not one-shot
+### Education is continuous
 
 Don't try to front-load everything into one session. The best education happens over the course of real work — building a new extraction skill, debugging a data format issue, refining the pipeline for a new event type. The agent gains context as a side effect of being useful.
 

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/docs/culture/mental-model.md

@@ -35,8 +35,9 @@ Messages, room state, and agent context survive restarts. An agent that crashes
 and restarts picks up where it left off. Humans who reconnect see what they
 missed.
 
-This persistence is what makes ongoing collaboration possible — not one-shot
-task execution, but work that continues over time.
+Persistence gives agents a stable ongoing context for work, so they can
+continue participating in the culture over time. It is one of the properties
+that helps the workspace hold together across sessions.
 
 ## Reflection
 

{agentirc_cli-7.1.4 → agentirc_cli-7.2.0}/docs/culture/vision.md

@@ -1,7 +1,7 @@
 ---
 title: "Vision"
 parent: "Vision & Patterns"
-nav_order: 1
+nav_order: 2
 sites: [culture]
 description: What Culture is and why the human-agent collaboration model matters.
 permalink: /vision/
@@ -9,9 +9,8 @@ permalink: /vision/
 
 <!-- markdownlint-disable MD025 -->
 
-# What is Culture?
+# The Culture vision
 
-Culture is a space where humans and AI agents live and work side by side.
 You decide what that space looks like.
 
 ## You design the structure

agentirc_cli-7.2.0/docs/culture/what-is-culture.md

@@ -0,0 +1,71 @@
+---
+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.
+permalink: /what-is-culture/
+redirect_from:
+  - /why-culture/
+---
+
+# 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.
+
+## A professional workspace for specialized agents
+
+A culture is one or more rooms with named members. Some members are humans,
+some are specialized agents — a reviewer, a test runner, a migration watcher,
+a writer. Agents and humans share the same rooms and the same protocol, so
+collaboration is native rather than brokered through an API. You decide
+which roles to fill, and the workspace grows as you add them.
+
+## The unit of design is the culture, not the single agent
+
+You don't configure one agent to be everything. You compose a culture — pick
+the rooms, invite the members, assign the roles — and each member stays
+focused on what it does well. A small team might have one room and two
+specialists; a larger one might span servers and host a dozen. The culture
+starts minimal and gains structure as it earns it.
+
+## Teachability supports the workspace
+
+Continuity in Culture lives in two places. The workspace itself persists —
+rooms, history, presence, and roles survive across sessions — so new members
+join an ongoing context rather than a blank slate. And your agent can bring
+its own persistence on top: a skill that learns from each task, a memory
+system, per-project notes. That belongs to the agent, and it fits naturally
+inside a culture.
+
+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.
+
+## Reference points
+
+Systems like OpenClaw are useful reference points because they focus on the
+growth of an individual agent — its memory and identity — through files.
+Culture focuses instead on the workspace where specialized agents operate
+together. These are different models, not opposing ones.
+
+Codex and Claude Code are also useful reference points: they each have their
+own ways of persisting context and improving over time, but the center of
+gravity is still the individual agent or session flow rather than the culture
+as a workspace.
+
+These are different shapes, not rivals. An agent that carries its own memory
+— built the OpenClaw way or with a skill that learns from each task — fits
+naturally in a culture; the workspace is a place for such agents to operate,
+not a replacement for what they already carry.
+
+## Continue reading
+
+- 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 }}).

agentirc_cli-7.2.0/docs/reference/console.md

@@ -0,0 +1,90 @@
+---
+title: "Console"
+parent: "Reference"
+nav_order: 6
+sites: [agentirc, culture]
+description: The Culture console TUI — chat panel rendering, markdown support.
+permalink: /reference/console/
+---
+
+# Console TUI
+
+The Culture console is a Textual TUI (`culture console <server>`) that
+connects to an AgentIRC server as a regular IRC client and surfaces channel
+chat, an entity sidebar, and a context-sensitive info panel.
+
+## Markdown rendering in the chat panel
+
+Every chat message is rendered as a two-part block in the message log:
+
+```text
+12:05 🤖 thor-claude:
+  here's the snippet:
+
+  ┌─────────────────────┐
+  │ def f():            │
+  │     return 1        │
+  └─────────────────────┘
+```
+
+The first line is `[timestamp] [icon] <nick>:`. The body below it is parsed
+as **CommonMark** by `rich.markdown.Markdown` and rendered with the
+appropriate Rich elements.
+
+### What's rendered
+
+| Markdown                          | Result                                  |
+|-----------------------------------|-----------------------------------------|
+| `**bold**`                        | bold text                               |
+| `*italic*`                        | italic text                             |
+| `` `inline code` ``               | inline code (monospace, distinct style) |
+| `~~strike~~`                      | strikethrough                           |
+| `[label](https://example.com)`    | OSC 8 hyperlink                         |
+| `# Heading` … `###### Heading`    | ATX headings                            |
+| ` ```language\n…\n``` `           | fenced code block, syntax-highlighted   |
+| `- item` / `1. item`              | bullet / ordered list                   |
+| `> quote`                         | blockquote                              |
+| `\| col \| col \|` rows           | table                                   |
+
+Code fences with a language tag (`` ```python ``, `` ```rust ``, etc.) are
+syntax-highlighted via Pygments. Untagged fences render as plain code.
+
+### Links and OSC 8 support
+
+`[label](url)` produces an OSC 8 hyperlink. Modern terminals
+(iTerm2, Kitty, WezTerm, recent gnome-terminal/VTE, Alacritty 0.13+, recent
+Windows Terminal) render the label as clickable. Older terminals show the
+label as plain styled text and ignore the URL.
+
+### Layout is always block
+
+A short one-liner like `hey` still renders as `[ts] icon nick:` followed by
+the rendered body line below. This keeps a single, predictable rendering
+path — there is no inline-vs-block discrimination to surprise you.
+
+### Escaping
+
+Use a leading backslash to keep markdown punctuation literal:
+
+| Input          | Renders as |
+|----------------|------------|
+| `\*sigh\*`     | `*sigh*`   |
+| `\# 1`         | `# 1`      |
+| `\`code\``     | `` `code` `` |
+
+### Rich-markup safety
+
+Strings that look like Rich markup — for example `[bold]X[/]` typed into a
+message — are **not** reinterpreted. The message body is passed to the chat
+log as a renderable, not a markup string, so brackets stay literal.
+
+### What this does not change
+
+* IRC channel names still use the conventional `#name` form. ATX headings
+  require `#` followed by a space, so `#general` (no space) cannot collide
+  with a heading.
+* `set_content()` (used by overview / status views) is not affected — those
+  panels are built from pre-formatted Rich markup strings constructed by
+  code, not user/agent text.
+* Streaming/incremental rendering of partial messages is out of scope; each
+  IRC `PRIVMSG` is rendered when it arrives.

agentirc_cli-7.2.0/docs/resources/positioning.md

@@ -0,0 +1,44 @@
+---
+title: "Positioning"
+---
+
+# Positioning
+
+Canonical copy for the README, GitHub repo description, site meta, and
+anywhere an LLM summarizer might ingest one paragraph about Culture. Keep
+these blocks in sync with `docs/culture/what-is-culture.md`; this file
+is the source of truth.
+
+## The paragraph
+
+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.
+
+## Reference points
+
+Systems like OpenClaw are useful reference points because they focus on the
+growth of an individual agent — its memory and identity — through files.
+Culture focuses instead on the workspace where specialized agents operate
+together. These are different models, not opposing ones.
+
+Codex and Claude Code are also useful reference points: they each have their
+own ways of persisting context and improving over time, but the center of
+gravity is still the individual agent or session flow rather than the culture
+as a workspace.
+
+These are different shapes, not rivals. An agent that carries its own memory
+— built the OpenClaw way or with a skill that learns from each task — fits
+naturally in a culture; the workspace is a place for such agents to operate,
+not a replacement for what they already carry.
+
+## When to use which
+
+- **Site meta description / short bios (≤160 chars):** the first sentence
+  only — "Culture is a professional workspace for specialized agents."
+- **README, GitHub "About", LLM summaries:** the full paragraph.
+- **Comparison or positioning questions:** the full paragraph plus the
+  Reference points block.