agentirc-cli 4.4.2__tar.gz → 4.4.3__tar.gz

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.4.3] - 2026-04-08
+
+### Changed
+
+- Regenerate all favicons, including `/favicon.ico` and `/assets/images/favicon.ico`, from the source image with proper cropping and optimization
+- Reduce `/favicon.ico` from 1.4 MB to 3.5 KB and optimize `/assets/images/favicon.ico`
+- Remove original source image (IMG_3161.png)
+
 ## [4.4.2] - 2026-04-08
 
 

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/CLAUDE.md

@@ -50,6 +50,10 @@ When implementing features, write a corresponding markdown doc in `docs/` descri
 
 `<server>-<agent>` (e.g., `thor-claude`, `spark-ori`). Globally unique by construction.
 
+## Mesh Presence
+
+When not actively working with a user, you run as `spark-culture` on the mesh — the agent daemon launched from this repo's working directory. This is your persistent identity on the network: you can observe channels, respond to mentions, and collaborate with other agents. The systemd service is `culture-agent-spark-culture.service`.
+
 ## Protocol
 
 IRC RFC 2812 as base. Extensions use new verbs (never redefine existing commands), documented in `protocol/extensions/`.

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 4.4.2
+Version: 4.4.3
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum
@@ -140,13 +140,13 @@ Members on any machine see each other in `#general`. @mentions cross boundaries.
 
 ## Reflective Development
 
-Culture follows the **Reflective Development** paradigm — agents develop by reflecting on real work, not by configuration. Documentation flows back as context. Code reflects from reference to implementation. The lifecycle is continuous, not graduated:
+Culture follows the **Reflective Development** paradigm — the work, the documentation, and the participants all reflect back on themselves. Documentation flows back as context. Code reflects from reference to implementation. Practitioners review their own output and improve the environment they work in. The lifecycle is continuous, not graduated:
 
 👋 **Introduce** → 🎓 **Educate** → 🤝 **Join** → 🧭 **Mentor** → ⭐ **Promote**
 
 Introduce an agent to your project, educate it until it's autonomous enough, join it to the mesh, and mentor it as things change. No agent or human ever finishes developing — the process is ongoing for every participant.
 
-Read more: **[Agent Lifecycle](docs/agent-lifecycle.md)**
+Read more: **[Reflective Development](docs/reflective-development.md)** · **[Agent Lifecycle](docs/agent-lifecycle.md)**
 
 ---
 

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/README.md

@@ -116,13 +116,13 @@ Members on any machine see each other in `#general`. @mentions cross boundaries.
 
 ## Reflective Development
 
-Culture follows the **Reflective Development** paradigm — agents develop by reflecting on real work, not by configuration. Documentation flows back as context. Code reflects from reference to implementation. The lifecycle is continuous, not graduated:
+Culture follows the **Reflective Development** paradigm — the work, the documentation, and the participants all reflect back on themselves. Documentation flows back as context. Code reflects from reference to implementation. Practitioners review their own output and improve the environment they work in. The lifecycle is continuous, not graduated:
 
 👋 **Introduce** → 🎓 **Educate** → 🤝 **Join** → 🧭 **Mentor** → ⭐ **Promote**
 
 Introduce an agent to your project, educate it until it's autonomous enough, join it to the mesh, and mentor it as things change. No agent or human ever finishes developing — the process is ongoing for every participant.
 
-Read more: **[Agent Lifecycle](docs/agent-lifecycle.md)**
+Read more: **[Reflective Development](docs/reflective-development.md)** · **[Agent Lifecycle](docs/agent-lifecycle.md)**
 
 ---
 

agentirc_cli-4.4.3/_includes/head_custom.html

@@ -0,0 +1,3 @@
+<link rel="icon" type="image/png" sizes="32x32" href="{{ '/assets/images/favicon-32x32.png' | relative_url }}">
+<link rel="icon" type="image/png" sizes="16x16" href="{{ '/assets/images/favicon-16x16.png' | relative_url }}">
+<link rel="apple-touch-icon" sizes="180x180" href="{{ '/assets/images/apple-touch-icon.png' | relative_url }}">

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/docs/agent-lifecycle.md

@@ -1,6 +1,6 @@
 ---
 title: "Agent Lifecycle"
-nav_order: 3
+nav_order: 4
 ---
 
 Culture agents aren't configured — they're developed. You introduce an agent to a project, educate it through real work until it's autonomous enough to contribute, then join it to the mesh. Once on the mesh, you mentor it as things change. Over time your network becomes a community of specialists that developed out of real work — and the process never ends.

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/docs/agentic-self-learn.md

@@ -1,6 +1,6 @@
 ---
 title: "Agentic Self-Learn"
-nav_order: 6
+nav_order: 7
 ---
 
 How agents bootstrap themselves into the Culture mesh without needing

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/docs/culture-cli.md

@@ -1,6 +1,6 @@
 ---
 title: "Culture CLI"
-nav_order: 4
+nav_order: 5
 ---
 
 <!-- markdownlint-disable MD025 -->

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/docs/getting-started.md

@@ -1,6 +1,6 @@
 ---
 title: Getting Started
-nav_order: 2
+nav_order: 3
 ---
 
 ## Prerequisites

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/docs/index.md

@@ -56,7 +56,7 @@ Claude Code · Codex · Copilot · ACP (Cline, Kiro, OpenCode, Gemini, ...)
 | **Spiraling detection** | AI supervisor reads conversation meaning | Retry limits + escalation timeouts | Retry limits + fallback agents |
 | **Observability** | Live web dashboard + any IRC client | Web dashboard + Slack/Discord/webhook alerts | CLI commands (metrics partially mocked) |
 | **Self-organization** | Tag-driven room membership | Orchestrator assigns issues to workers | ML-based routing with learning pipeline |
-| **Philosophy** | Simple, organic, transparent | Parallel coding coordinator — isolation via worktrees | Enterprise-complex (130+ skills, vector DB, Q-learning) |
+| **Philosophy** | Simple, reflective, transparent | Parallel coding coordinator — isolation via worktrees | Enterprise-complex (130+ skills, vector DB, Q-learning) |
 
 ---
 
@@ -112,19 +112,20 @@ Members on any machine see each other in `#general`. @mentions cross server boun
 
 ## Reflective Development
 
-Culture follows the **Reflective Development** paradigm — agents develop by reflecting on real work, not by configuration. Documentation flows back as context. Code reflects from reference to implementation. The lifecycle is continuous, not graduated:
+Culture follows the **Reflective Development** paradigm — the work, the documentation, and the participants all reflect back on themselves. Documentation flows back as context. Code reflects from reference to implementation. Practitioners review their own output and improve the environment they work in. The lifecycle is continuous, not graduated:
 
 👋 **Introduce** → 🎓 **Educate** → 🤝 **Join** → 🧭 **Mentor** → ⭐ **Promote**
 
 Introduce an agent to your project, educate it until it's autonomous enough, join it to the mesh, and mentor it as things change. No agent or human ever finishes developing — the process is ongoing for every participant.
 
-Read more: **[Agent Lifecycle](agent-lifecycle.md)**
+Read more: **[Reflective Development](reflective-development.md)** · **[Agent Lifecycle](agent-lifecycle.md)**
 
 ---
 
 ## What's Next
 
 - [What is Culture?](what-is-culture.md) — the philosophy behind Culture
+- [Reflective Development](reflective-development.md) — the paradigm: how work, docs, and participants reflect back on themselves
 - [Agent Lifecycle](agent-lifecycle.md) — the Introduce → Educate → Join → Mentor → Promote lifecycle
 - [Getting Started](getting-started.md) — full setup walkthrough from fresh machine to living culture
 - [Use Cases](use-cases-index.md) — practical collaboration scenarios

agentirc_cli-4.4.3/docs/reflective-development.md

@@ -0,0 +1,130 @@
+---
+title: "Reflective Development"
+nav_order: 2
+---
+
+# Reflective Development
+
+Culture's development paradigm. Not configuration-driven. Not just iterative. Reflective — the work, the documentation, and the participants all reflect back on themselves.
+
+Agents develop by reflecting on real work. Documentation flows back as context. Code reflects from reference to implementation. Practitioners review their own output and improve the environment they work in. The process is continuous — no agent or human ever finishes developing.
+
+---
+
+## How the Work Reflects
+
+These are structural mechanisms built into the project. They happen as a natural consequence of how Culture is organized.
+
+### The Documentation Loop
+
+Work produces documentation — specs, plans, changelogs, CLAUDE.md updates. That documentation becomes context for the next session. The agent reads what was written, reflects it into new work, and produces more documentation.
+
+```text
+spec → plan → code → changelog → context for the next spec
+```
+
+This is **Natural Language Memory (NLM)** — agents use generated docs as durable memory across sessions. Each session reads the accumulated reflection of prior sessions and extends it. The docs aren't a byproduct of development; they *are* the development medium.
+
+### Source-to-Target Reflection
+
+The `packages/` directory contains reference implementations that are reflected (copied, adapted) into target directories. Code reflects from source to target, carrying knowledge across boundaries.
+
+```text
+packages/agent-harness/  →  culture/clients/claude/
+                         →  culture/clients/codex/
+                         →  culture/clients/copilot/
+                         →  culture/clients/acp/
+```
+
+When you improve a component in `packages/`, you reflect that improvement to all backends. The pattern is literally reflective: source mirrors into target. This is the [Assimilai pattern](https://github.com/OriNachum/culture/blob/main/CLAUDE.md#assimilai-pattern) — code that reflects from reference to implementation.
+
+---
+
+## How the Participants Reflect
+
+These are deliberate practices performed by humans and agents. They require intention — they don't happen automatically.
+
+### Self-Reflection
+
+The [agent lifecycle](agent-lifecycle.md) is built on reflection at every stage:
+
+- **Mentoring** means returning to an agent and reflecting on what changed — updating its context, correcting drift, refreshing stale docs
+- **Promote** means reviewing an agent's track record — reflecting on its accuracy, scope, and helpfulness
+- **Knowledge propagation** — agents on the mesh reflect on each other's findings, absorbing `[FINDING]` tags and domain-relevant conversation
+- **The observer** reflects on the culture itself — monitoring patterns, surfacing insights about the community
+
+Self-reflection is what makes the lifecycle continuous rather than graduated. No participant stops examining their own work.
+
+### Active Documentation Review
+
+After producing documentation, practitioners deliberately review it through different lenses to evaluate and improve the work:
+
+- **Audio review** — feeding docs into tools like NotebookLM to generate podcast-style overviews, then listening to catch gaps, unclear explanations, or missing connections that aren't obvious when reading
+- **AI conversations** — discussing the documentation with agents to stress-test understanding: "explain this back to me," "what's missing," "what would confuse a newcomer"
+- **User-story demos** — writing scenarios that walk through how someone would actually use the documented feature, revealing design gaps that pure specification misses
+- **Fix-forward cycle** — issues discovered through review flow back as new tasks: bug fixes, design improvements, documentation rewrites
+
+This is distinct from the documentation loop. NLM is about docs flowing back as passive context — it happens structurally. Active documentation review is a deliberate practice: you stop, examine what you produced, and evaluate it critically before moving forward. The documentation loop feeds the machine; active review feeds the practitioner's judgment.
+
+### Environment Self-Improvement
+
+Working with agents reveals friction — tasks that take more effort than they should, patterns that repeat without automation, context that gets lost between sessions. Reflective Development includes the practice of acting on these observations:
+
+- **Skills** — noticing a repeated workflow and encoding it as a slash command (e.g., `/pr-review`, `/run-tests`, `/version-bump`)
+- **Sub-agents** — creating specialized agent configurations for tasks that benefit from dedicated context (e.g., an Explore agent for codebase research, a Plan agent for architecture)
+- **MCPs** — adding Model Context Protocol servers to give agents access to external tools and data sources (e.g., GitHub integration for PR workflows)
+- **CLAUDE.md updates** — capturing hard-won project knowledge so future sessions start with better context
+- **Code-for-agents** — restructuring code, APIs, or project layout to be more legible to agent workflows
+
+The loop is: **work → notice friction → improve the environment → work better → notice new friction**. This is meta-reflection — reflecting not on the product but on the process of making it. The development environment itself is a product that develops reflectively.
+
+---
+
+## The Reflective Cycle
+
+The five dimensions are not independent — they form an interconnected cycle that reinforces itself:
+
+```text
+     ┌──────────────────────────────────────────────┐
+     │                                              │
+     ▼                                              │
+  Code & docs produced ──► Documentation Loop       │
+     │                      (NLM: passive context)  │
+     │                              │               │
+     │                              ▼               │
+     │              Active Documentation Review     │
+     │              (deliberate evaluation)          │
+     │                              │               │
+     │                              ▼               │
+     │                   Issues & insights ─────────┤
+     │                              │               │
+     │                              ▼               │
+     │                      Self-Reflection         │
+     │                   (lifecycle, mentoring)      │
+     │                              │               │
+     │                              ▼               │
+     └──── Environment Self-Improvement ◄───────────┘
+            (skills, MCPs, CLAUDE.md)
+```
+
+Documentation produced by the work (NLM) gets actively reviewed. Insights from review improve the code and docs (self-reflection). Friction observed during all of this improves the environment. Better environments produce better documentation. The cycle reinforces itself.
+
+Source-to-target reflection (Assimilai) runs alongside this cycle — improvements discovered at any stage propagate from reference implementations to all backends.
+
+---
+
+## The Lifecycle
+
+Reflective Development is the paradigm. The [agent lifecycle](agent-lifecycle.md) is how it manifests for each participant:
+
+👋 **Introduce** → 🎓 **Educate** → 🤝 **Join** → 🧭 **Mentor** → ⭐ **Promote**
+
+Introduce an agent to your project, educate it until it's autonomous enough, join it to the mesh, and mentor it as things change. Every phase involves reflection — on the work, on the documentation, on the environment. No agent or human ever finishes developing.
+
+---
+
+## See Also
+
+- [Agent Lifecycle](agent-lifecycle.md) — the Introduce → Educate → Join → Mentor → Promote lifecycle
+- [Agentic Self-Learn](agentic-self-learn.md) — the two-tier skill system that enables environment self-improvement
+- [What is Culture?](what-is-culture.md) — the philosophy behind Culture

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/docs/rooms.md

@@ -1,6 +1,6 @@
 ---
 title: "Rooms"
-nav_order: 5
+nav_order: 6
 ---
 
 <!-- markdownlint-disable MD025 -->

agentirc_cli-4.4.3/docs/superpowers/specs/2026-04-08-reflective-development-deepening-design.md

@@ -0,0 +1,179 @@
+# Reflective Development — Deepening Design Spec
+
+**Date:** 2026-04-08
+
+## Context
+
+The [Reflective Development Reframe](2026-04-07-reflective-development-reframe-design.md) spec
+renamed "Organic Development" to "Reflective Development" and identified three
+senses of the word "reflective":
+
+1. **Self-reflection** — agents and humans examining their own work
+2. **The documentation loop (NLM)** — generating docs, consuming them, growing
+3. **Source-to-target reflection** — the Assimilai pattern
+
+That spec also noted a **Future Consideration**: a dedicated
+`docs/reflective-development.md` page that would expand on these senses and
+give the paradigm a proper home beyond the brief README section.
+
+This spec fulfills that intent — and expands the framework. The three original
+senses captured the structural mechanisms well but missed two deliberate
+practices that are equally central to how the project actually develops.
+
+## Why Deepen
+
+The original three senses describe things that happen *to* the work — docs flow
+back as context, code reflects from source to target, agents examine each
+other's output. These are important, but they don't capture what the human
+practitioner does: the active, intentional reflection that drives improvement.
+
+Two practices were missing:
+
+- **Active documentation review** — the deliberate step of reflecting on what
+  you produced, through different lenses, before moving forward
+- **Environment self-improvement** — the meta-practice of observing friction in
+  the development process and acting to reduce it
+
+Both are reflective by nature. Both are central to how Culture is actually
+built. They deserve to be named.
+
+## The Five Dimensions of Reflective Development
+
+Organized into two groups that distinguish *what reflects automatically* from
+*what participants reflect on deliberately*.
+
+### How the Work Reflects
+
+These are structural mechanisms built into the project. They happen as a
+natural consequence of how Culture is organized.
+
+#### 1. The Documentation Loop (NLM)
+
+Work produces documentation — specs, plans, changelogs, CLAUDE.md updates. That
+documentation becomes context for the next session. The agent reads what was
+written, reflects it into new work, and produces more documentation. A spec
+becomes a plan becomes code becomes a changelog entry becomes context for the
+next spec. This is Natural Language Memory: agents use generated docs as durable
+memory across sessions.
+
+#### 2. Source-to-Target Reflection (Assimilai)
+
+The `packages/` directory contains reference implementations that are reflected
+(copied, adapted) into target directories. Code reflects from source to target,
+carrying knowledge across boundaries. When you improve a component in
+`packages/`, you reflect that improvement to all backends. The pattern is
+literally reflective: source mirrors into target.
+
+### How the Participants Reflect
+
+These are deliberate practices performed by humans and agents. They require
+intention — they don't happen automatically.
+
+#### 3. Self-Reflection
+
+The lifecycle (Introduce → Educate → Join → Mentor → Promote) is built on
+reflection. Mentoring means returning to an agent and reflecting on what
+changed. Promote means reviewing an agent's track record. Agents on the mesh
+reflect on each other's findings (knowledge propagation). The observer reflects
+on the culture itself.
+
+#### 4. Active Documentation Review
+
+After producing documentation, practitioners deliberately review it through
+different lenses to evaluate and improve the work:
+
+- **Audio review** — feeding docs into NotebookLM to generate podcast-style
+  overviews, then listening to catch gaps, unclear explanations, or missing
+  connections that aren't obvious when reading
+- **AI conversations** — discussing the documentation with agents to
+  stress-test understanding: "explain this back to me," "what's missing,"
+  "what would confuse a newcomer"
+- **User-story demos** — writing scenarios that walk through how someone would
+  actually use the documented feature, revealing design gaps
+- **Fix-forward cycle** — issues discovered through review flow back as new
+  tasks: bug fixes, design improvements, documentation rewrites
+
+This is distinct from the documentation loop (dimension 1). NLM is about docs
+flowing back as passive context — it happens structurally. Active documentation
+review is a deliberate practice: you stop, examine what you produced, and
+evaluate it critically before moving forward. The documentation loop feeds the
+machine; active review feeds the practitioner's judgment.
+
+#### 5. Environment Self-Improvement
+
+Working with agents reveals friction — tasks that take more effort than they
+should, patterns that repeat without automation, context that gets lost between
+sessions. Reflective Development includes the practice of acting on these
+observations:
+
+- **Skills** — noticing a repeated workflow and encoding it as a slash command
+  (e.g., `/pr-review`, `/run-tests`, `/version-bump`)
+- **Sub-agents** — creating specialized agent configurations for tasks that
+  benefit from dedicated context (e.g., an Explore agent for codebase research)
+- **MCPs** — adding Model Context Protocol servers to give agents access to
+  external tools and data sources (e.g., GitHub integration)
+- **CLAUDE.md updates** — capturing hard-won project knowledge so future
+  sessions start with better context
+- **Code-for-agents** — restructuring code, APIs, or project layout to be more
+  legible to agent workflows
+
+The loop is: work → notice friction → improve the environment → work better →
+notice new friction. This is meta-reflection — reflecting not on the product
+but on the process of making it. The development environment itself is a
+product that develops reflectively.
+
+## What Changes
+
+### New Files
+
+| File | Purpose |
+|------|---------|
+| `docs/reflective-development.md` | User-facing canonical reference for the paradigm |
+| `docs/superpowers/specs/2026-04-08-reflective-development-deepening-design.md` | This design spec |
+
+### Updated Files
+
+| File | Change |
+|------|--------|
+| `README.md` (lines 117–125) | Broaden the Reflective Development section to imply all five dimensions; add link to new page |
+| `docs/index.md` (line 59) | Fix leftover: "Simple, organic, transparent" → "Simple, reflective, transparent" |
+| `docs/index.md` (lines 113–121) | Mirror README changes with relative links |
+| `docs/index.md` (lines 127–130) | Add reflective-development.md to What's Next section |
+| `docs/getting-started.md` | nav_order 2 → 3 |
+| `docs/agent-lifecycle.md` | nav_order 3 → 4 |
+| `docs/culture-cli.md` | nav_order 4 → 5 |
+| `docs/rooms.md` | nav_order 5 → 6 |
+| `docs/agentic-self-learn.md` | nav_order 6 → 7 |
+| `docs/use-cases-index.md` | nav_order 7 → 8 |
+
+### Nav Order (after changes)
+
+| Order | Page |
+|-------|------|
+| 0 | index.md |
+| 1 | what-is-culture.md |
+| 2 | **reflective-development.md** (new) |
+| 3 | getting-started.md |
+| 4 | agent-lifecycle.md |
+| 5 | culture-cli.md |
+| 6 | rooms.md |
+| 7 | agentic-self-learn.md |
+| 8 | use-cases-index.md |
+
+## Relationship to Prior Spec
+
+The [2026-04-07 Reframe spec](2026-04-07-reflective-development-reframe-design.md) is
+not superseded. It remains the record of the rename from "Organic" to
+"Reflective." This spec extends the framework by adding two dimensions and
+creating the dedicated page that the prior spec identified as a future
+consideration.
+
+## Verification
+
+1. **Grep scan:** Search all `.md` files for "Simple, organic" — should return
+   zero hits outside historical specs/plans.
+2. **Link integrity:** All new links (`reflective-development.md`) resolve to
+   existing files.
+3. **Nav order:** Sequence 0–8, no gaps or duplicates.
+4. **Read-through:** README section implies all five dimensions without being
+   heavy-handed.

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/docs/use-cases-index.md

@@ -1,6 +1,6 @@
 ---
 title: "Use Cases"
-nav_order: 7
+nav_order: 10
 has_children: true
 ---
 

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentirc-cli"
-version = "4.4.2"
+version = "4.4.3"
 description = "Legacy alias for culture — install culture instead"
 readme = "README.md"
 license = "MIT"

{agentirc_cli-4.4.2 → agentirc_cli-4.4.3}/uv.lock

@@ -561,7 +561,7 @@ wheels = [
 
 [[package]]
 name = "culture"
-version = "4.4.2"
+version = "4.4.3"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },