guild-cli 0.3.0__tar.gz → 0.4.2__tar.gz

guild_cli-0.4.2/.claude/skills/agent-config/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: agent-config
+description: >
+  Show a Culture agent's full configuration in one read-only view: its
+  system-prompt file (CLAUDE.md / AGENTS.md / GEMINI.md), the parallel
+  culture.yaml, and the agent's local .claude/skills index. Use when an
+  operator says "show agent <name>", "what does <agent> look like", or before
+  teaching/onboarding an agent and you need to see its current kit + config.
+  Backs the `guild show` verb. Vendored from steward (cite-don't-import);
+  inventory only — it reports, it does not judge alignment or drift.
+type: command
+---
+
+# agent-config — surface a Culture agent's config in one view
+
+guildmaster is the mesh's skills supplier and owns the **inventory** surfaces:
+"what kit + config does this agent have?" This skill answers exactly that for a
+single agent, showing the three artifacts that together define it:
+
+1. **System-prompt file** (`CLAUDE.md` / `AGENTS.md` / `GEMINI.md`) — the
+   prompt-side guidance for the agent's backend. The script detects which file
+   is present from a backend-fingerprint registry.
+2. **`culture.yaml`** — the runtime-side config (`agents:` list with `suffix`,
+   `backend`, `model`, `system_prompt`, `channels`, `tags`, `acp_command`,
+   `extras`). Lives parallel to the prompt file at the project root.
+3. **`.claude/skills/*/SKILL.md`** — the per-project skills the agent can
+   invoke, one line each (name + truncated description).
+
+This is the **inventory half** of the steward → guildmaster split
+([issue #12](https://github.com/agentculture/guildmaster/issues/12)): it reports
+the config, it does **not** interpret drift or judge alignment. The relationship
+graph and the "is this agent aligned?" judgment stay with `steward overview` /
+`steward doctor`.
+
+## When to use
+
+- Before `guild teach` / `guild onboard` — see an agent's current kit + config.
+- When an operator asks "show me agent `<name>`" or "what does `<agent>` run".
+- Read it, don't guess — before answering a question about what an agent does.
+
+## How to run
+
+One script, two ways to call it (or just run `guild show`, which wraps it):
+
+```bash
+# Path mode — point at any directory with a prompt file + culture.yaml
+.claude/skills/agent-config/scripts/show.sh ../culture
+
+# Suffix mode — resolve a registered agent suffix via the Culture server's
+# manifest (location set by culture_server_yaml in skills.local.yaml)
+.claude/skills/agent-config/scripts/show.sh daria
+```
+
+Output is three sections: the detected system-prompt file, `culture.yaml` (or
+`(missing)`), and a one-line summary per local skill (name + description,
+truncated to 120 chars).
+
+## What to look at in `culture.yaml`
+
+| Field | Why it matters |
+|-------|----------------|
+| `suffix` | Identifies the agent on the mesh. |
+| `backend` | One of `claude` / `codex` / `copilot` / `acp`. The all-backends rule means a feature in one must land in all four. |
+| `model` | Drift here changes behavior silently. |
+| `system_prompt` | Should not contradict the prompt file. |
+| `channels` | Where the agent listens. |
+| `tags`, `extras`, `acp_command` | Backend-specific. |
+
+## Notes
+
+- **Read-only.** The script never edits agent files. It reports; it does not
+  flag or fix drift — that judgment is steward's lane.
+- **Backend-aware.** Prompt-file detection comes from
+  `data/backend-fingerprints.yaml` (the `prompt:` mapping), falling back to the
+  built-in `(CLAUDE.md AGENTS.md GEMINI.md)` list if the registry is absent.
+- **Per-machine config.** Suffix mode reads `culture_server_yaml` from
+  `.claude/skills.local.yaml` (git-ignored), falling back to
+  `.claude/skills.local.yaml.example`.
+- **Vendored from steward** (`agent-config`). guildmaster owns this copy and may
+  diverge; re-sync from steward's canonical copy when it changes. Divergences:
+  the SKILL.md is reframed for guildmaster's inventory role and adds
+  `type: command` for the culture backend's skill loader.

guild_cli-0.4.2/.claude/skills/agent-config/data/backend-fingerprints.yaml

@@ -0,0 +1,30 @@
+# Canonical backend fingerprint registry. Vendored from steward's agent-config
+# skill (cite-don't-import); guildmaster owns this copy. Read by the agent-config
+# show.sh (bash), which `guild show` shells out to. Upstream steward also reads
+# it from a Python detector; guildmaster has no parallel detector, so only the
+# `backends:` prompt mapping below is load-bearing here. Keep that mapping in
+# sync with upstream when re-syncing.
+#
+# `prompt`        — the backend's system-prompt filename at the repo root.
+# `steering`      — files/dirs distinctive enough to attribute to this backend.
+# `shared_steering` — files/dirs that belong to NO specific backend. A repo
+#                   declared as any backend may have these without triggering a
+#                   mismatch. `.agents` is a generic Culture agent-config
+#                   convention. `.claude/settings.json` and
+#                   `.claude/settings.local.json` are generic Claude Code
+#                   (editor/CLI) workspace config files — they appear in any
+#                   repo that uses Claude Code as the development tool,
+#                   regardless of the agent backend, so they must never be used
+#                   to infer the backend or flag a mismatch. The claude backend
+#                   is identified solely by its `CLAUDE.md` prompt file.
+#                   `.github/copilot-instructions.md` is generic GitHub Copilot
+#                   editor/IDE config — any repo may have it regardless of the
+#                   declared agent backend, so it must not trigger a mismatch.
+backends:
+  claude:  { prompt: CLAUDE.md, steering: [] }
+  codex:   { prompt: AGENTS.md, steering: [".codex"] }
+  acp:     { prompt: AGENTS.md, steering: [".kiro"] }
+  copilot: { prompt: AGENTS.md, steering: [] }
+  gemini:  { prompt: GEMINI.md, steering: [".gemini"] }
+shared_steering: [".agents", ".claude/settings.json", ".claude/settings.local.json", ".github/copilot-instructions.md"]
+prompt_fallback: AGENTS.md

guild_cli-0.4.2/.claude/skills/agent-config/scripts/show.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+set -euo pipefail
+# Show a Culture agent's full configuration in one view:
+# the detected system-prompt file (CLAUDE.md / AGENTS.md / GEMINI.md), the
+# parallel culture.yaml, and the .claude/skills/ index.
+#
+# Usage: show.sh <path-or-agent-suffix>
+#
+# Path mode:   show.sh ../culture
+# Suffix mode: show.sh daria   (resolved via culture_server_yaml in skills.local.yaml)
+#
+# Exit codes:
+#   0   success
+#   1   environment error (missing manifest, missing PyYAML for suffix mode)
+#   2   user error (no target given, unknown suffix, target path doesn't exist)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKILL_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_ROOT="$(cd "$SKILL_DIR/../../.." && pwd)"
+
+CFG="$REPO_ROOT/.claude/skills.local.yaml"
+[ -f "$CFG" ] || CFG="$REPO_ROOT/.claude/skills.local.yaml.example"
+
+# Read a top-level YAML scalar from CFG. Schema is intentionally tiny:
+#   key: value     (with optional surrounding quotes / trailing comment)
+# No PyYAML dependency.
+read_cfg() {
+    awk -v key="$1" '
+        $0 ~ ("^" key ":[[:space:]]*") {
+            sub("^" key ":[[:space:]]*", "")
+            sub(/[[:space:]]*#.*$/, "")
+            sub(/^[[:space:]]+/, ""); sub(/[[:space:]]+$/, "")
+            sub(/^["\047]/, ""); sub(/["\047]$/, "")
+            print
+            exit
+        }
+    ' "$CFG"
+}
+
+target="${1:-}"
+if [ -z "$target" ]; then
+    echo "Usage: $(basename "$0") <path-or-agent-suffix>" >&2
+    exit 2
+fi
+
+if [ -d "$target" ]; then
+    DIR="$target"
+else
+    SERVER_YAML_RAW="$(read_cfg culture_server_yaml)"
+    SERVER_YAML="${SERVER_YAML_RAW/#\~/$HOME}"
+    if [ ! -f "$SERVER_YAML" ]; then
+        echo "no server manifest at $SERVER_YAML — set culture_server_yaml in $CFG" >&2
+        echo "or pass an explicit path instead of suffix '$target'" >&2
+        exit 1
+    fi
+    # Suffix mode parses Culture's server manifest, whose schema is dictated by
+    # Culture (not by us) and includes nested mappings — too rich for awk.
+    # We use python+PyYAML here, with a friendly install hint if it's missing.
+    if ! python3 -c 'import yaml' 2>/dev/null; then
+        echo "suffix mode needs Python + PyYAML to parse $SERVER_YAML" >&2
+        echo "  install: pip install --user pyyaml   (or: uv pip install pyyaml)" >&2
+        echo "  or pass an explicit path instead of suffix '$target'" >&2
+        exit 1
+    fi
+    # Use a dedicated exit code (2) for "unknown suffix" so the steward CLI
+    # wrapper can distinguish user errors (typo'd suffix) from env errors
+    # (missing manifest / PyYAML).
+    if ! DIR=$(python3 - "$SERVER_YAML" "$target" <<'PY'
+import sys, yaml, pathlib
+manifest_path, suffix = sys.argv[1], sys.argv[2]
+m = yaml.safe_load(pathlib.Path(manifest_path).read_text()) or {}
+agents = m.get('agents', {})
+entry = agents.get(suffix)
+if entry is None:
+    print(f"no agent registered with suffix {suffix!r} in {manifest_path}", file=sys.stderr)
+    sys.exit(2)
+print(entry['directory'] if isinstance(entry, dict) else entry)
+PY
+); then
+        exit 2
+    fi
+fi
+
+DIR="${DIR/#\~/$HOME}"
+
+# Recognized prompt filenames come from the shared registry (single source
+# of truth with the Python detector). Fall back to the built-in list if the
+# registry isn't present (e.g. skill vendored without the data file).
+REGISTRY="$SKILL_DIR/data/backend-fingerprints.yaml"
+prompt_files=()
+if [ -f "$REGISTRY" ]; then
+    while IFS= read -r pf; do
+        [ -n "$pf" ] && prompt_files+=("$pf")
+    done < <(grep -oE 'prompt:[[:space:]]*[^,}[:space:]]+' "$REGISTRY" | awk '{print $NF}' | sort -u)
+fi
+[ ${#prompt_files[@]} -eq 0 ] && prompt_files=(CLAUDE.md AGENTS.md GEMINI.md)
+
+shown=0
+for pf in "${prompt_files[@]}"; do
+    if [ -f "$DIR/$pf" ]; then
+        echo "=== $DIR/$pf ==="
+        cat "$DIR/$pf"
+        echo
+        shown=1
+    fi
+done
+if [ "$shown" -eq 0 ]; then
+    echo "=== $DIR (system prompt) ==="
+    echo "(no recognized prompt file: ${prompt_files[*]})"
+    echo
+fi
+echo "=== $DIR/culture.yaml ==="
+if [ -f "$DIR/culture.yaml" ]; then cat "$DIR/culture.yaml"; else echo "(missing)"; fi
+echo
+echo "=== $DIR/.claude/skills/ ==="
+found=0
+for s in "$DIR"/.claude/skills/*/SKILL.md; do
+    [ -f "$s" ] || continue
+    found=1
+    name=$(awk '/^name:/{print $2; exit}' "$s")
+    desc=$(awk '
+        /^description:/ {
+            sub(/^description:[[:space:]]*/, "")
+            buf = $0
+            flag = 1
+            next
+        }
+        flag && /^[a-z_-]+:/ { flag = 0 }
+        flag { buf = buf " " $0 }
+        END { gsub(/^[[:space:]]+|[[:space:]]+$/, "", buf); print buf }
+    ' "$s")
+    printf "  %-30s %s\n" "$name" "${desc:0:120}"
+done
+if [ "$found" -eq 0 ]; then
+    echo "  (no skills)"
+fi

guild_cli-0.4.2/.claude/skills/guild/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: guild
+description: >
+  Run guildmaster's skills-supplier overview and narrate it. Run `guild
+  overview` (via scripts/overview.sh) for the deterministic evidence pack — the
+  canonical skill set + versions/origins, the docs/skill-sources.md ledger, and
+  skills-scoped drift signals — then narrate three separated layers: observed
+  facts, inferred relationships, and suggestions (each naming the command that
+  enacts it). Use when an operator asks "what skills do we supply", "who
+  consumes what", "is anything drifting", or "what should I teach next".
+  Skills-scoped and reflect-only — it surfaces and interprets supplier-side
+  skill/version signals; it does NOT narrate the agent relationship graph or
+  judge alignment (that stays with steward's org-overview / steward doctor).
+  The skills-scoped excerpt of steward's `org-overview` narration contract
+  (cite-don't-import, issue #12).
+type: command
+---
+
+# guild — narrate guildmaster's own supplier surfaces
+
+guildmaster is the mesh's skills **supplier**, and it owns the *inventory*
+surfaces ([issue #12](https://github.com/agentculture/guildmaster/issues/12)).
+The per-agent half (`guild show`) is backed by the vendored `agent-config`
+skill. **This skill is the supplier half: the affordance for `guild overview`.**
+It houses the scripts that run guildmaster's own read-only CLI surfaces and the
+contract for narrating them — `overview` is the one script today.
+
+Unlike the vendored skills, this one is **guildmaster's own** (origin =
+`guildmaster`, not cited from steward): `guild overview` is a pure-Python,
+read-only CLI verb, and `scripts/overview.sh` is the thin deterministic wrapper
+that invokes it. The script picks how to call `guild` (installed console
+script → `uv run` → `python -m guild`) and delegates; it interprets nothing.
+
+**The load-bearing split** (this is the skills-scoped excerpt of steward's
+`org-overview` narration contract — issue #12, cite-don't-import):
+
+- **The CLI (`guild overview`) emits only deterministic facts** — the canonical
+  skill set, the ledger view, and neutral drift signals. No LLM, no
+  interpretation, mutates nothing.
+- **This skill is where the agent interprets** — turning those facts into
+  inferred relationships and suggestions. **Never present an inference as a
+  fact**, and keep the layers in separate sections.
+
+## What `overview` answers
+
+A skills-scoped evidence pack — **not** `steward overview`'s ecosystem
+relationship graph (issue #12: inventory → guildmaster; judgment → steward):
+
+1. **Canonical skill set + versions** — every skill guildmaster supplies, its
+   origin (`guildmaster`, or a sibling it only re-broadcasts), and the current
+   canonical version, plus per-skill consumers.
+2. **Ledger view** — who-consumes-which-skill, read from `docs/skill-sources.md`.
+3. **Drift signals** — canonical skills no one consumes, canonical skills the
+   ledger doesn't track yet, and per-agent kit gaps. These feed `teach` /
+   `onboard`.
+
+**Pre-cutover** the guildmaster ledger is still a consumer-side view with no
+"Downstream" column, so the supplier ledger is empty and drift is inactive; the
+verb reports the canonical set and says so plainly (see `docs/cutover.md`).
+
+**`--scope mesh`** is the ledger-free alternative: it surveys every agent in the
+workspace (`<workspace>/*/culture.yaml`) live off the filesystem and reports, per
+agent, each canonical skill as **current** / **stale** (the agent's copy differs
+from guildmaster's by content fingerprint) / **missing**, plus any non-canonical
+"extra" skills. Use it to answer "what's missing or stale, and where" *today*,
+without waiting for the cutover. Still skills-scoped — no relationship graph.
+
+## When to use
+
+- An operator asks "what skills do we supply" / "what's the canonical set".
+- "Who has skill `<x>`?" / "who consumes what?" / "is anything drifting?"
+- "What should I `teach` next?" — overview's gaps are the input to `teach`.
+- Before `guild teach` / `guild onboard`, to see uncovered skills and kit gaps.
+
+## How to run
+
+One script. Pick the scope (or just run `guild overview`, which this wraps):
+
+```bash
+# Whole mesh — the canonical set + ledger + drift across all agents (default)
+.claude/skills/guild/scripts/overview.sh
+
+# One agent — that agent's kit + gaps (first positional → --scope self)
+.claude/skills/guild/scripts/overview.sh daria
+
+# Mesh survey — every agent's skills + missing/stale, live off the filesystem
+.claude/skills/guild/scripts/overview.sh --scope mesh
+
+# Machine-readable evidence for precise reasoning
+.claude/skills/guild/scripts/overview.sh --json
+.claude/skills/guild/scripts/overview.sh --scope mesh --json
+```
+
+The script prints the CLI's markdown by default: the canonical-skill table, a
+ledger section, and a drift section. The exact per-skill consumer and gap lists
+live in `--json`.
+
+## Narrate three layers — never blur them
+
+`guild overview` emits only deterministic facts; this skill is where you
+interpret them. Keep the three layers in separate sections, and never present
+an inference as a fact:
+
+1. **Observed facts.** Summarize the canonical set + versions/origins and the
+   ledger view in your own words — lead with what the counts reveal (the
+   canonical set, who's behind, who's unregistered). State only what the CLI
+   reported; don't reproduce the raw signal lists verbatim (read `--json` only
+   when you need an exact list to act on). Pre-cutover, say so plainly: the
+   ledger has no downstream column yet, so consumers are empty and drift is
+   inactive.
+2. **Inferred relationships** (mark clearly as inferred). Connect facts no
+   single ledger row states outright — e.g. two consumers vendored from the
+   same upstream skill *both* lag a canonical bump (a shared exposure), or a
+   skill only `guildmaster` carries is a single point of supply.
+3. **Suggestions** (kept separate from facts, and *named, not run*). Seed these
+   from the skills-scoped drift signals — for each, name the concrete next step
+   and the command that enacts it, then stop.
+
+### Signal → suggestion (skills-scoped only)
+
+These are the **skill/version** signals `guild overview` emits — guildmaster's
+supplier lane:
+
+| Drift signal (from `guild overview`) | Reading | Named follow-up — name it, do NOT auto-run |
+|--------------------------------------|---------|--------------------------------------------|
+| `unledgered_skills` | a canonical skill the ledger doesn't track (no owner row) | Fix the ledger: add it to `docs/skill-sources.md` |
+| `uncovered_skills` | a canonical skill no agent consumes (orphan) | Confirm intentional, then `teach` it, or retire it |
+| `agent_gaps` (per-agent missing skill) | a consumer behind / missing a skill | `guild teach --skill <name> --to <agent>` to close the gap |
+| agent not registered in the ledger | a sibling not yet onboarded | `guild onboard --agent <owner/repo>` |
+| consumer behind the canonical pin (post-cutover) | a team on an outdated procedure | Re-vendor: `guild teach` / `onboard` to the current pin |
+
+### Out of scope — steward's lane
+
+The **relationship** signals — `overlap`, `over-connected-agent`,
+`isolated-repo` — and the typed agent relationship graph are **not** narrated
+here. Those belong to steward's `org-overview` / `steward overview`. guildmaster
+narrates skills/version drift, not the ecosystem graph or alignment judgment.
+
+### Reflect-only
+
+This skill **sees, reflects, and suggests — it does not act.** For every
+suggestion, name the concrete next step and the command that enacts it, then
+stop. Editing the ledger, filing an issue, or running `teach` / `onboard` is a
+separate, explicit step the operator chooses. The skill writes nothing to disk
+and mutates no repo — output is the chat conversation only. Read-only: no
+`--apply`, no mutation, no network/LLM call.

guild_cli-0.4.2/.claude/skills/guild/scripts/overview.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+set -euo pipefail
+# overview — assemble the `guild overview` skills-supplier evidence pack for
+# narration.
+#
+# The guildmaster agent runs this, then narrates the supplier view (the
+# canonical skill set + versions/origins, the docs/skill-sources.md ledger, and
+# the drift signals that feed `teach` / `onboard`). See SKILL.md.
+# Deterministic glue only: resolve guildmaster's repo root, run from there,
+# resolve how to invoke guild, pick the scope, and delegate to `guild overview`.
+# No interpretation.
+#
+# Usage:
+#   overview.sh                  # whole ledger across the mesh (--scope all)
+#   overview.sh <agent>          # one agent's kit + gaps       (--scope self)
+#   overview.sh --scope mesh     # live filesystem survey of every agent
+#   overview.sh --json           # all, JSON evidence
+#   overview.sh <agent> --json   # one agent, JSON evidence
+#
+# Contract: the FIRST argument, if it does not start with '-', is the agent
+# (self scope). All remaining arguments pass through to `guild overview`.
+#
+# Exit codes:
+#   0   success (delegates to `guild overview`; its exit code propagates)
+#   1   environment error (no way to invoke guild)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Resolve guildmaster's repo root and run from there, so `guild overview` always
+# reports guildmaster's canonical set regardless of the caller's working
+# directory (the CLI reads its repo from cwd). Prefer git (robust); fall back to
+# climbing out of the fixed .claude/skills/<name>/scripts/ layout when git is
+# unavailable.
+REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || true)"
+if [ -z "$REPO_ROOT" ]; then
+    REPO_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
+fi
+cd "$REPO_ROOT"
+
+# Resolve how to invoke guild: installed console script, then uv, then module.
+if command -v guild >/dev/null 2>&1; then
+    GUILD=(guild)
+elif [ -f "$REPO_ROOT/pyproject.toml" ] && command -v uv >/dev/null 2>&1; then
+    GUILD=(uv run --project "$REPO_ROOT" guild)
+elif command -v python3 >/dev/null 2>&1; then
+    GUILD=(python3 -m guild)
+else
+    echo "overview: cannot invoke guild (need 'guild', 'uv', or 'python3' on PATH)" >&2
+    exit 1
+fi
+
+# Honor an explicit --scope passed through (advanced use); otherwise pick one.
+has_scope=false
+for arg in "$@"; do
+    case "$arg" in
+        --scope | --scope=*)
+            has_scope=true
+            break
+            ;;
+    esac
+done
+
+overview_args=()
+if [ "$#" -gt 0 ] && [[ "$1" != -* ]]; then
+    # First arg is an agent → one-agent (self) scope.
+    agent="$1"
+    shift
+    $has_scope || overview_args+=(--scope self)
+    overview_args+=("$agent")
+else
+    # No leading agent → whole-ledger (all) view.
+    $has_scope || overview_args+=(--scope all)
+fi
+overview_args+=("$@")
+
+exec "${GUILD[@]}" overview "${overview_args[@]}"

{guild_cli-0.3.0 → guild_cli-0.4.2}/.claude/skills.local.yaml.example

@@ -3,7 +3,8 @@
 # Skills read skills.local.yaml first, falling back to this example.
 
 # Path to the Culture server's agent manifest (suffix → directory mapping).
-# Used by skills that resolve a registered agent suffix to its repo dir.
+# Used by skills that resolve a registered agent suffix to its repo dir —
+# e.g. the agent-config skill / `guild show <suffix>` (suffix mode).
 culture_server_yaml: ~/.culture/server.yaml
 
 # Sibling project paths checked by cross-repo skills (cicd alignment delta,

{guild_cli-0.3.0 → guild_cli-0.4.2}/CHANGELOG.md

@@ -5,6 +5,95 @@ All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/). This project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.2] - 2026-05-24
+
+### Added
+
+- **`guild overview --scope mesh`** — a live filesystem survey of the whole
+  workspace, the answer to "what skills does every agent have, and what's
+  missing or stale, and where" without waiting for the cutover. Discovers every
+  agent (`<workspace>/*/culture.yaml`, via the new `discover_agents` helper) and
+  reports, per agent, each canonical skill as **current** / **stale** (the
+  agent's copy differs from guildmaster's by content fingerprint —
+  `skill_fingerprint`) / **missing**, plus any non-canonical "extra" skills.
+  Markdown + `--json`; `--workspace-root DIR` overrides the surveyed root
+  (default: the parent of this repo). Read-only, inventory only — no
+  dependency/relationship graph (that stays steward's lane). The existing
+  ledger-based `--scope all` / `--scope self` are unchanged.
+
+### Changed
+
+### Fixed
+
+- Mesh-survey robustness (Qodo review on #15): `discover_agents` and
+  `iter_skills` now skip non-UTF-8 / unreadable `culture.yaml` and `SKILL.md`
+  (one bad file in a surveyed repo no longer crashes the run), and
+  `skill_fingerprint` skips symlinks (never follows links outside the skill dir;
+  keeps the digest deterministic).
+
+## [0.4.1] - 2026-05-24
+
+### Added
+
+- **`guild` skill** — the backing affordance + narration skill for `guild
+  overview`, the supplier-overview half of the inventory split (sibling to the
+  vendored `agent-config` skill that backs `guild show`). `scripts/overview.sh`
+  is a deterministic wrapper that resolves how to invoke `guild` (installed →
+  `uv` → `python -m guild`) and delegates to `guild overview`; `SKILL.md` is the
+  **skills-scoped excerpt of steward's `org-overview` narration contract**
+  ([#12](https://github.com/agentculture/guildmaster/issues/12),
+  cite-don't-import): narrate three separated layers — observed facts, inferred
+  relationships, suggestions (each naming its enacting `teach` / `onboard` /
+  ledger command), reflect-only. Skills/version scope only — does NOT narrate
+  steward's relationship-graph signals (`overlap` / `over-connected-agent` /
+  `isolated-repo`). Recorded in `docs/skill-sources.md` as guildmaster-origin
+  (not vendored).
+
+### Changed
+
+- `SELF_SKILLS` now includes `guild` — guildmaster's own affordance skill is
+  excluded from the canonical kit it supplies to siblings (like `teach` /
+  `onboard`), since it wraps the `guild` binary and is meaningless elsewhere.
+
+### Fixed
+
+## [0.4.0] - 2026-05-24
+
+### Added
+
+- **`guild overview`** — guildmaster's read-only skills-supplier overview surface
+  ([#12](https://github.com/agentculture/guildmaster/issues/12)): the canonical
+  skill set + versions/origins, the `docs/skill-sources.md` ledger view, and
+  drift signals (unledgered skills, uncovered skills, per-agent kit gaps).
+  `--scope all` (default) and `--scope self <agent>`; markdown or `--json`.
+  Pure-Python, read-only — no `--apply`, no mutation, no LLM. Degrades
+  gracefully pre-cutover: when the ledger has no downstream column the verb
+  reports the canonical set and notes that drift activates after the
+  steward→guildmaster cutover. Skills-scoped only — does not reproduce
+  `steward overview`'s ecosystem relationship graph.
+- **`guild show <path-or-suffix>`** — one agent's full config in one read-only
+  view ([#12](https://github.com/agentculture/guildmaster/issues/12)): the
+  detected system-prompt file (`CLAUDE.md` / `AGENTS.md` / `GEMINI.md`), the
+  parallel `culture.yaml`, and the `.claude/skills` index. Path mode or suffix
+  mode (resolved via `culture_server_yaml`). Target resolution happens once in
+  Python; the human view shells out to the vendored `agent-config` `show.sh`
+  (mirroring `steward show`), while `--json` emits a structured object (prompt
+  file + contents, parsed `culture.yaml`, skills index) built natively. Failure
+  output stays the structured `error:` / `hint:` shape. Inventory only — it
+  reports, it does not judge drift.
+- **`agent-config` skill** vendored from steward (cite-don't-import) to back
+  `guild show`: `scripts/show.sh` + `data/backend-fingerprints.yaml` verbatim;
+  SKILL.md reframed for guildmaster's inventory role + `type: command`. Recorded
+  in `docs/skill-sources.md`; now part of the canonical skill set.
+- `guild.skills.ledger.supplier_skills` / `consumer_map` — pure helpers that
+  read the supplier ledger (skills tracked + their consumers) for `overview`.
+
+### Changed
+
+- `VERBS` index + `README.md` + `CLAUDE.md` document the new inventory verbs and
+  the issue #12 division of labor (inventory → guildmaster; alignment judgment →
+  steward).
+
 ## [0.3.0] - 2026-05-24
 
 ### Added

{guild_cli-0.3.0 → guild_cli-0.4.2}/CLAUDE.md

@@ -106,6 +106,32 @@ asked for one; guildmaster fulfills the broadcast *role* via these two instead).
 Going live is gated on the steward→guildmaster cutover (`docs/cutover.md`) — no
 two live broadcasters.
 
+**Inventory verbs — `overview` & `show` (the read-only surfaces).** guildmaster
+owns the mesh's *inventory* surfaces per
+[issue #12](https://github.com/agentculture/guildmaster/issues/12) — the
+"what kit + config does an agent have?" view. The dividing rule from issue #12:
+**inventory → guildmaster; judgment ("how do agents relate / are they aligned?")
+→ steward.** Neither verb clones `steward overview`'s relationship graph.
+
+- `guild overview [--scope all|self <agent>|mesh]` — the supplier view:
+  canonical skill set + versions/origins, the `docs/skill-sources.md` ledger,
+  and drift signals (uncovered skills, per-agent kit gaps). Pure-Python,
+  read-only, **no `--apply`**. Pre-cutover the ledger has no downstream column,
+  so `--scope all`/`self` drift is inactive and the verb says so (reads
+  whichever ledger is authoritative). `--scope mesh` is the ledger-free
+  alternative: it surveys every agent in the workspace
+  (`<workspace>/*/culture.yaml`) live off the filesystem and reports, per agent,
+  each canonical skill as current / **stale** (content fingerprint differs from
+  guildmaster's copy) / **missing** — answering "what's missing or stale, and
+  where" today. Still inventory only — no relationship graph.
+- `guild show <path-or-suffix>` — one agent's full config: detected prompt file
+  (`CLAUDE.md` / `AGENTS.md` / `GEMINI.md`), parallel `culture.yaml`, and the
+  `.claude/skills` index. Thin wrapper that shells out to the vendored
+  `agent-config` skill's `show.sh` (cite-don't-import from steward), mirroring
+  `steward show`. Path mode or suffix mode (resolved via `culture_server_yaml`).
+
+Both **report**; they do not flag or fix drift (that judgment is steward's lane).
+
 **Backend:** guildmaster is a CLI *plus* an agent like steward, so the natural
 fit is `backend: claude` with this `CLAUDE.md` as the runtime prompt and a
 `culture.yaml` declaring the `guildmaster` agent suffix (steward's is

{guild_cli-0.3.0 → guild_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guild-cli
-Version: 0.3.0
+Version: 0.4.2
 Summary: guildmaster — an agent and CLI that manages skills for the AgentCulture mesh.
 Project-URL: Homepage, https://github.com/agentculture/guildmaster
 Project-URL: Issues, https://github.com/agentculture/guildmaster/issues
@@ -94,6 +94,34 @@ verification). After: **one command** propagates a skill set, or onboards a
 sibling end-to-end. Going live is gated on the staged steward→guildmaster
 cutover — see [`docs/cutover.md`](docs/cutover.md).
 
+### Inventory verbs — `overview` & `show`
+
+guildmaster owns the mesh's **inventory** surfaces (the read-only "what kit +
+config does an agent have?" view) per
+[issue #12](https://github.com/agentculture/guildmaster/issues/12). Both are
+read-only — no `--apply`, no mutation, no drift verdict (judgment stays with
+`steward overview` / `steward doctor`).
+
+| Verb | What it does |
+|------|--------------|
+| `guild overview [--scope all\|self <agent>\|mesh]` | The supplier view: the canonical skill set + versions/origins, the `docs/skill-sources.md` ledger, and drift signals (uncovered skills, per-agent kit gaps). Feeds `teach` / `onboard`. `--scope mesh` instead surveys every agent's vendored skills live off the filesystem and flags what's **missing**/**stale** per agent. |
+| `guild show <path-or-suffix>` | One agent's full config in one view — its detected prompt file (`CLAUDE.md` / `AGENTS.md` / `GEMINI.md`), its parallel `culture.yaml`, and its `.claude/skills` index. |
+
+```bash
+uv run guild overview                       # whole ledger + canonical set
+uv run guild overview --scope self daria    # one agent's kit + gaps
+uv run guild overview --scope mesh          # live survey: every agent's skills + missing/stale
+uv run guild show ../culture                 # config by path
+uv run guild show daria                      # config by registered suffix
+uv run guild show ../culture --json          # structured config object
+```
+
+`guild show` resolves a registered suffix via the Culture server manifest
+(`culture_server_yaml` in `.claude/skills.local.yaml`); pass an explicit
+directory path to skip the lookup. Pre-cutover the ledger is still a
+consumer-side view with no downstream column, so `overview`'s drift signals
+activate only after the steward→guildmaster cutover — the verb says so plainly.
+
 ## Develop
 
 ```bash