agentculture

Run pytest with parallel execution and coverage. Use when running tests, verifying changes, or the user says "run tests", "test", or "pytest".

Cross-repo + mesh communication: file tracked GitHub issues on sibling repos, comment on existing issues, fetch issues with body + comments to inline current state into briefs, and send live messages to Culture mesh channels. Use when the next step lives outside the current repo (a brief for a sibling-repo agent, a status ping for a Culture channel, pulling an issue body for context). Issue I/O is backed by `agtag` (>=0.1); agtag auto-signs from the local `culture.yaml`. Mesh messages are unsigned (the IRC nick is the speaker).

Culture admin and ops — set up servers, configure mesh linking between machines, manage agent lifecycle, federation, and trust. Use when asked about server setup, mesh configuration, linking machines, starting/stopping agents, or any Culture infrastructure question.

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope culture --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via this s

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope culture --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to memo

Ask colleague — a *different* backend/model than you (e.g. a local vLLM Qwen) — to take a scoped repo task off your plate, then fold its answer back. The point isn't a stronger model; it's a second, independent mind, and that diversity is the value: `ask-colleague review` gets a candid second opinion on a diff, `ask-colleague explore` gets a fresh read of an area, `ask-colleague write` hands off a small implementation, `ask-colleague feedback` grades a finished work item (the ROI loop), and `ask-colleague clean` reaps stale/corrupt `colleague/*` branches a crashed run left behind (which can break `git fetch`). Reach for it REFLEXIVELY, the way you'd lean over to the teammate at the next desk — not only when asked: before you present or open a PR on a non-trivial committed diff, run `review` for a diverse second opinion; for a fresh read of an unfamiliar area whose answer is independent of your current context, run `explore`. Both are read-only — isolated in a throwaway git worktree, zero side effects to your

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 guildmaster (cite-don't-import; guildmaster forked it from steward, which keeps an alignment-judgment variant); inventory only — it reports, it does not judge alignment or drift.

Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent. Human gates: the exported spec, the implementation split plan (task map + per-task agent/model proposal + go/no-go), and the final PR. The devague CLI stays deterministic and non-orchestrating (#20) — it only *describes* the graph via `devague plan waves`; the operator (main agent) performs the fan-out. Use when the user says "assign to workforce", "fan out the plan", "parallel subagents", or after /spec-to-plan exports a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster re-broadcasts it to the AgentCulture mesh — it originates in devague, not guildmaster (the supplier post steward→guildmaster cutover).

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope reachy-mini-mcp --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix vi

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope reachy-mini-mcp --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save

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.

Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent. Human gates: the exported spec, the implementation split plan (task map + per-task agent/model proposal + go/no-go), and the final PR. The devague CLI stays deterministic and non-orchestrating (#20) — it only *describes* the graph via `devague plan waves`; the operator (main agent) performs the fan-out. Use when the user says "assign to workforce", "fan out the plan", "parallel subagents", or after /spec-to-plan exports a plan. Authored and maintained in agentculture/devague (origin = devague); steward pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from steward like the other skills here.

reachy-mini-mcp's CI/CD lane, layered on `devex pr`. Delegates lint / open / read / reply / delta to devex; adds two extensions — `status` (SonarCloud quality gate + hotspots + unresolved-thread tally) and `await` (read --wait + status with non-zero exit on Sonar ERROR or unresolved threads). Use when: creating PRs in reachy-mini-mcp, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads". Renamed from `pr-review` in steward 0.7.0; rebased on devex in 0.12.0.

Cross-repo + mesh communication from reachy-mini-mcp: file tracked GitHub issues on sibling repos, fetch issues from sibling repos to inline current state into briefs, and send live messages to Culture mesh channels. Use when the next step lives outside reachy-mini-mcp (a brief for a sibling-repo agent, a status ping for a Culture channel, or pulling an issue body + comments into context). Issue posts auto-sign with `- reachy-mini-mcp (Claude)`; mesh messages are unsigned (the IRC nick is the speaker). Not for in-reachy-mini-mcp issues — use `gh issue create` or the `cicd` skill for those. Renamed from `coordinate` in steward 0.8.0; absorbed `gh-issues` in 0.9.1. Issue I/O is backed by `agtag` (>=0.1) starting in 0.11.0.

Verify that committed docs (README.md, CLAUDE.md, SKILL.md descriptions) still describe what the code and tests actually do. Use at the end of a plan, before PR creation, or when the user says "check doc-test alignment", "verify docs", or "do the docs still match the code". STUB — `scripts/check.sh` exits with a not-yet-implemented error today; the contract for what it will do lives in this file.

Hand a scoped repo task to convertible — a *different* engine/model than you (e.g. a local vLLM Qwen) — and fold its answer back. The point isn't a stronger model; it's a different mind, and diversity helps: `outsource review` gets an independent second opinion on a diff, `outsource explore` gets a fresh read of an area, `outsource write` delegates a small implementation. Use when the user says "outsource this", "get a second opinion", "have convertible review/explore/ write", "ask the other model", or when you want a diverse perspective rather than just doing it yourself. Read-only verbs (explore/review) run isolated in a throwaway git worktree and cannot touch the working tree.

Close the loop after an assign-to-workforce run by turning what actually happened into an accountability artifact — planned versus actual delivery, mid-work decisions, plan drift, evidence-backed delivery claims, and remaining work. The plan the user confirmed is the contract; this skill records where execution obeyed it, where it changed, and what is genuinely safe to claim as delivered. Runs on complete, partial, AND failed runs — failure is reported faithfully, never smoothed over. Use when the user says "summarize delivery", "delivery summary", "wrap up", "close the loop", "what did we actually ship", or "plan versus actual", or after assign-to-workforce merges (or fails to merge) a plan's waves. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.

Ask colleague — a *different* backend/model than you (e.g. a local vLLM Qwen) — to take a scoped repo task off your plate, then fold its answer back. The point isn't a stronger model; it's a second, independent mind, and that diversity is the value: `ask-colleague review` gets a candid second opinion on a diff, `ask-colleague explore` gets a fresh read of an area, `ask-colleague write` hands off a small implementation, `ask-colleague feedback` grades a finished work item (the ROI loop), and `ask-colleague clean` reaps stale/corrupt `colleague/*` branches a crashed run left behind (which can break `git fetch`). Pilot a running work item with `monitor`/`guide`/`stop`. Reach for it REFLEXIVELY, the way you'd lean over to the teammate at the next desk — not only when asked: before you present or open a PR on a non-trivial committed diff, run `review` for a diverse second opinion; for a fresh read of an unfamiliar area whose answer is independent of your current context, run `explore`. Both are read-only — isolate

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store uses visibility-aware routing: PUBLIC records inside a git repo go to <repo-root>/.eidetic/memory (committed, team-shared); PRIVATE records, or any record outside a git repo, go to $HOME/.eidetic/memory (never committed). An explicit EIDETIC_DATA_DIR wins and short-circuits to that single dir. Recall reads both stores and merges. The wrapper defaults queries to this agent's PERSONAL, PUBLIC scope (`--scope colleague --visibility public`, suffix re

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store uses visibility-aware routing: PUBLIC records inside a git repo go to <repo-root>/.eidetic/memory (committed, team-shared); PRIVATE records, or any record outside a git repo, go to $HOME/.eidetic/memory (never committed). An explicit EIDETIC_DATA_DIR wins and short-circuits to that single dir. The wrapper defaults records to this agent's PERSONAL, PUBLIC scope (`--scope colleague --visibility public`, suffix read from culture.yaml) so a plain /remember commits to <repo-root>/.eidetic/memory (in-repo, team-shar

Graduate colleague from a task runner into a persistent Culture mesh peer — the born → trained → resident lifecycle transition. Mints + self-registers a stable mesh identity, selects channels, and (with --serve) connects to IRC and runs the resident until interrupted. Requires the opt-in [culture] extra. Use when an operator wants to elevate their colleague instance into a long-lived Culture member that owns a channel and answers messages directly.

colleague's CI/CD lane, layered on `devex pr` (the same PR-lifecycle CLI as `agex`, invoked under the `devex` name). Delegates lint / open / read / reply / delta to devex; adds two extensions — `status` (SonarCloud quality gate + hotspots + unresolved-thread tally) and `await` (read --wait + status with non-zero exit on Sonar ERROR or unresolved threads). Use when: creating PRs in colleague, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads". Renamed from `pr-review` in steward 0.7.0; rebased on agex/devex in 0.12.0.

Cross-repo + mesh communication from colleague: file tracked GitHub issues on sibling repos, fetch issues from sibling repos to inline current state into briefs, and send live messages to Culture mesh channels. Use when the next step lives outside colleague (a brief for a sibling-repo agent, a status ping for a Culture channel, or pulling an issue body + comments into context). Issue posts auto-sign with `- colleague (Claude)`; mesh messages are unsigned (the IRC nick is the speaker). Not for in-colleague issues — use `gh issue create` or the `cicd` skill for those. Renamed from `coordinate` in steward 0.8.0; absorbed `gh-issues` in 0.9.1. Issue I/O is backed by `agtag` (>=0.1) starting in 0.11.0.

Verify that committed docs (README.md, CLAUDE.md, SKILL.md descriptions) still describe what the code and tests actually do. Use at the end of a plan, before PR creation, or when the user says "check doc-test alignment", "verify docs", or "do the docs still match the code".

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope lobes --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via this ski

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope lobes --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to memory

Ask colleague — a *different* backend/model than you (e.g. a local vLLM Qwen) — to take a scoped repo task off your plate, then fold its answer back. The point isn't a stronger model; it's a second, independent mind, and that diversity is the value: `ask-colleague review` gets a candid second opinion on a diff, `ask-colleague explore` gets a fresh read of an area, `ask-colleague write` hands off a small implementation, `ask-colleague feedback` grades a finished work item (the ROI loop), and `ask-colleague clean` reaps stale/corrupt `colleague/*` branches a crashed run left behind (which can break `git fetch`). Pilot a running work item with `monitor`/`guide`/`stop`. Reach for it REFLEXIVELY, the way you'd lean over to the teammate at the next desk — not only when asked: before you present or open a PR on a non-trivial committed diff, run `review` for a diverse second opinion; for a fresh read of an unfamiliar area whose answer is independent of your current context, run `explore`. Both are read-only — isolate

Steward's CI/CD lane, layered on `agex pr`. Delegates lint / open / read / reply / delta to agex; adds two steward extensions — `status` (SonarCloud quality gate + hotspots + unresolved-thread tally) and `await` (read --wait + status with non-zero exit on Sonar ERROR or unresolved threads). Use when: creating PRs in steward, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads". Renamed from `pr-review` in steward 0.7.0; rebased on agex in 0.12.0.

Cross-repo + mesh communication from steward: file tracked GitHub issues on sibling repos, fetch issues from sibling repos to inline current state into briefs, and send live messages to Culture mesh channels. Use when the next step lives outside steward (a brief for a sibling-repo agent, a status ping for a Culture channel, or pulling an issue body + comments into context). Issue posts auto-sign with `- steward (Claude)`; mesh messages are unsigned (the IRC nick is the speaker). Not for in-steward issues — use `gh issue create` or the `cicd` skill for those. Renamed from `coordinate` in steward 0.8.0; absorbed `gh-issues` in 0.9.1. Issue I/O is backed by `agtag` (>=0.1) starting in 0.11.0.

Verify that committed docs (README.md, CLAUDE.md, SKILL.md descriptions) still describe what the code and tests actually do. Use at the end of a plan, before PR creation, or when the user says "check doc-test alignment", "verify docs", or "do the docs still match the code". STUB — `scripts/check.sh` exits with a not-yet-implemented error today; the contract for what it will do lives in this file.

Run, assess, and switch the local vLLM model via the `lobes` CLI (lobes-cli). Use when changing the served model, starting/stopping the server, load-testing a candidate (e.g. an NVFP4 checkpoint), or producing the numbers for a per-model doc under docs/.

Run pytest with parallel execution and coverage. Use when running tests, verifying changes, or the user says "run tests", "test", or "pytest".

Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent. Human gates: the exported spec, the implementation split plan (task map + per-task agent/model proposal + go/no-go), and the final PR. The devague CLI stays deterministic and non-orchestrating (#20) — it only *describes* the graph via `devague plan waves`; the operator (main agent) performs the fan-out. Use when the user says "assign to workforce", "fan out the plan", "parallel subagents", or after /spec-to-plan exports a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

Stop an in-flight assign-to-workforce run the moment execution must diverge from the confirmed plan, get explicit human approval for the divergence, and record it as a first-class, append-only deviation record via `devague deviate` before resuming — never fold a deviation silently into drift after the fact. Use when the user says "deviate from the plan", "we need to change the plan mid-run", "record a deviation", "this isn't matching the plan anymore", or when a task agent discovers the confirmed plan no longer matches reality partway through a workforce run. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

Close the loop after an assign-to-workforce run by turning what actually happened into an accountability artifact — planned versus actual delivery, mid-work decisions, plan drift, evidence-backed delivery claims, and remaining work. The plan the user confirmed is the contract; this skill records where execution obeyed it, where it changed, and what is genuinely safe to claim as delivered. Runs on complete, partial, AND failed runs — failure is reported faithfully, never smoothed over. Use when the user says "summarize delivery", "delivery summary", "wrap up", "close the loop", "what did we actually ship", or "plan versus actual", or after assign-to-workforce merges (or fails to merge) a plan's waves. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.

Explore the scope of a vague idea BEFORE framing it into a spec (the idea→scope leg; the optional opening move ahead of /think). Survey the surfaces the idea touches — code, docs, skills, CI, sibling repos — and seed the coming Announcement Frame with boundary, non-goal, and assumption claims that cite what was actually explored (provenance, not generic disclaimers). Use when the user says "explore scope", "scope this idea", "what does this touch", "map the scope", "scope exploration", or when an idea touches an existing codebase and speccing it cold would mean guessing its boundaries. Hand off to the sibling /think skill to build the frame. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.

Turn a converged devague spec into a buildable plan by working forwards (the spec→plan leg; drives the `devague plan` CLI group). Seed a plan from a converged frame, add tasks that collectively cover every coverage target (the frame's confirmed claims + honesty conditions), give each task acceptance criteria and an honest dependency order, park genuine unknowns as first-class risks, and export a plan only once it *converges*. Use when the user says "spec to plan", "stp", "turn this spec into a plan", "plan this spec", "make a build plan", or after the /think skill exports a spec. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the `devague` CLI). Start from the announcement ("pretend it shipped"), capture and classify claims, interrogate them with honesty conditions and hard questions, park open vagueness as a first-class object, and export a spec only once the frame *converges*. Use when the user says "think this through", "spec this", "work backwards", "turn this idea into a spec", "announcement frame", or "devague", or when a feature request is too vague to build yet. Once a spec exports, hand off to the sibling /spec-to-plan skill to turn it into a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope devague --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via this s

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope devague --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to memo

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope auntiepypi --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via thi

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope auntiepypi --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to m

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 via guildmaster (origin steward; cite-don't-import); inventory only — it reports, it does not judge alignment or drift.

auntiepypi's CI/CD lane, layered on `agex pr`. Delegates lint / open / read / reply / delta to agex; adds two extensions — `status` (SonarCloud quality gate + hotspots + unresolved-thread tally) and `await` (read --wait + status with non-zero exit on Sonar ERROR or unresolved threads). Use when: creating PRs in auntiepypi, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads". Renamed from `pr-review` in steward 0.7.0; rebased on agex in 0.12.0.

Cross-repo + mesh communication from auntiepypi: file tracked GitHub issues on sibling repos, fetch issues from sibling repos to inline current state into briefs, and send live messages to Culture mesh channels. Use when the next step lives outside auntiepypi (a brief for a sibling-repo agent, a status ping for a Culture channel, or pulling an issue body + comments into context). Issue posts auto-sign with `- auntiepypi (Claude)`; mesh messages are unsigned (the IRC nick is the speaker). Not for in-auntiepypi issues — use `gh issue create` or the `cicd` skill for those. Renamed from `coordinate` in steward 0.8.0; absorbed `gh-issues` in 0.9.1. Issue I/O is backed by `agtag` (>=0.1) starting in 0.11.0.

Verify that committed docs (README.md, CLAUDE.md, SKILL.md descriptions) still describe what the code and tests actually do. Use at the end of a plan, before PR creation, or when the user says "check doc-test alignment", "verify docs", or "do the docs still match the code". STUB — `scripts/check.sh` exits with a not-yet-implemented error today; the contract for what it will do lives in this file.

Switch a PyPI package install between the production index, TestPyPI pre-release builds, and a local editable checkout. Use when an agent maintains a package and needs to verify a TestPyPI dev build before promoting to production, or when the user says "install from test-pypi", "switch to local", "change package source", or "install from pypi".

Run pytest with parallel execution and coverage. Use when running tests, verifying changes, or the user says "run tests", "test", or "pytest".

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope code-lens-cli --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope code-lens-cli --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save t

Steward's CI/CD lane, layered on `agex pr`. Delegates lint / open / read / reply / delta to agex; adds two steward extensions — `status` (SonarCloud quality gate + hotspots + unresolved-thread tally) and `await` (read --wait + status with non-zero exit on Sonar ERROR or unresolved threads). Use when: creating PRs in steward, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads". Renamed from `pr-review` in steward 0.7.0; rebased on agex in 0.12.0.

Pick the verb by the question you're asking, not the tool you'd otherwise reach for. Three questions, three one-call answers: **"What changed in the last N commits — which functions or classes did each commit add, remove, or modify?"** → use `recent`, **not** `git log` + `git show` + manual diff reading. `scripts/recent.sh [<path>] [-n N]` returns `{"commits": [{"sha","date","subject","changes":[{"file","added","removed","modified"}, …]}, …]}` — the symbol diff is computed via AST, so you skip the manual "what functions changed" step. The `modified` heuristic compares function line-spans; pure line shifts can cause false positives (a deferred improvement). **"Where is `<pattern>` referenced — and what function or class owns each match?"** → use `grep`, **not** `rg`/`grep` + Read each file to find the enclosing scope. `scripts/grep.sh <pattern> [<path>]` returns `{"pattern","matches":[{"file","line","scope","text"}, …]}` — `scope` is the enclosing Python function or class, resolved via AST. Requires `ripgrep`

Cross-repo + mesh communication from steward: file tracked GitHub issues on sibling repos, fetch issues from sibling repos to inline current state into briefs, and send live messages to Culture mesh channels. Use when the next step lives outside steward (a brief for a sibling-repo agent, a status ping for a Culture channel, or pulling an issue body + comments into context). Issue posts auto-sign with `- steward (Claude)`; mesh messages are unsigned (the IRC nick is the speaker). Not for in-steward issues — use `gh issue create` or the `cicd` skill for those. Renamed from `coordinate` in steward 0.8.0; absorbed `gh-issues` in 0.9.1. Issue I/O is backed by `agtag` (>=0.1) starting in 0.11.0.

Mechanical facts about a Python repo or a workspace of related repos — in one tool call, instead of N grep/read calls. `scripts/profile.sh <path>` returns: package name, version, repo path, manifest type + language, entry points, runtime + dev deps, flat package layout, depth-2 package tree, build_test (test cmd + coverage gate + python_requires), ci_workflows, publish_target (PyPI/GHCR + trigger), git_remote (host/owner/repo parsed from origin), module_summaries (per-module first-docstring-line summaries), vendored skills with upstream provenance, last 3 changelog entries, CITATION.md table, CLAUDE.md "Project status" body, extras (culture nick, …); with default online enrichment, also returns `github_state` (latest release, open issue count, default branch, CI status on default) and `pypi_state` (published version + release date). Pass `--basic` to skip Tier-2 and return Tier-1 mechanical facts only. Add `--depth deep` for: README intro, design-related CLAUDE.md sections, last 10 commit subjects. `scripts/c

Run pytest with parallel execution and coverage. Use when running tests, verifying changes, or the user says "run tests", "test", or "pytest".

Query SonarCloud API for code quality data. Use when: checking quality gate status, fetching code issues or security hotspots, reviewing metrics (coverage, bugs, code smells), or the user says "sonar", "quality gate", "code quality", "sonarclaude".

Launch and drive the real irc-lens web console to verify a change at its surface — build/launch/drive recipe for this repo (serve against a live AgentIRC, curl the routes, degrade-state probes). Use when verifying nontrivial changes end-to-end before committing, when asked to run or screenshot the console, or when tests alone can't show runtime behavior.

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope irc-lens --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via this

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope irc-lens --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to mem

irc-lens CI/CD lane: open PR (auto-wait for Qodo/Copilot), push fixes (re-poll bots), triage feedback, reply, resolve. Adds a portability lint (no absolute /home paths, no per-user dotfile refs in committed docs), an alignment-delta check when CLAUDE.md or culture.yaml change, and greenfield-aware test/version-bump steps. Use when: creating PRs in irc-lens, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads". Vendored from steward's `cicd` skill — see the `irc-lens notes` section below for the agentfront-contract guardrails specific to this repo.

Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent. Human gates: the exported spec, the implementation split plan (task map + per-task agent/model proposal + go/no-go), and the final PR. The devague CLI stays deterministic and non-orchestrating (#20) — it only *describes* the graph via `devague plan waves`; the operator (main agent) performs the fan-out. Use when the user says "assign to workforce", "fan out the plan", "parallel subagents", or after /spec-to-plan exports a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

Explore the scope of a vague idea BEFORE framing it into a spec (the idea→scope leg; the optional opening move ahead of /think). Survey the surfaces the idea touches — code, docs, skills, CI, sibling repos — and seed the coming Announcement Frame with boundary, non-goal, and assumption claims that cite what was actually explored (provenance, not generic disclaimers). Use when the user says "explore scope", "scope this idea", "what does this touch", "map the scope", "scope exploration", or when an idea touches an existing codebase and speccing it cold would mean guessing its boundaries. Hand off to the sibling /think skill to build the frame. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.

Turn a converged devague spec into a buildable plan by working forwards (the spec→plan leg; drives the `devague plan` CLI group). Seed a plan from a converged frame, add tasks that collectively cover every coverage target (the frame's confirmed claims + honesty conditions), give each task acceptance criteria and an honest dependency order, park genuine unknowns as first-class risks, and export a plan only once it *converges*. Use when the user says "spec to plan", "stp", "turn this spec into a plan", "plan this spec", "make a build plan", or after the /think skill exports a spec. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the `devague` CLI). Start from the announcement ("pretend it shipped"), capture and classify claims, interrogate them with honesty conditions and hard questions, park open vagueness as a first-class object, and export a spec only once the frame *converges*. Use when the user says "think this through", "spec this", "work backwards", "turn this idea into a spec", "announcement frame", or "devague", or when a feature request is too vague to build yet. Once a spec exports, hand off to the sibling /spec-to-plan skill to turn it into a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

Bootstrap a new aligned AgentCulture sibling end-to-end: GitHub repo create, local clone, afi-cli scaffold, and pypi/testpypi Trusted-Publishing Environments. Each gitculture step dry-runs first and waits for confirmation before applying. Use when starting a new sibling (e.g. "bootstrap a new sibling called X", "create a new agentculture repo", "stand up the next sibling").

Verify that claims in CLAUDE.md (GitHub endpoints, required scopes, bootstrap step order) still match what the code in `gitculture/` actually does. Run before merging anything that touches CLAUDE.md or the `gitculture.cli._commands.repo` module — catches doc drift that a normal pytest pass would not.

Approve many pull requests at once across a whole GitHub org (or one repo), selecting them by a title heading. Composes two gitculture verbs — `gitculture pr list` (read-only org-wide search) to discover the matches and `gitculture pr approve` (one approving review each) to act — so it inherits gitculture's dry-run-default mutation safety: it shows every PR it *would* approve before you pass --apply. Per-PR failures (most often "can't approve your own pull request") are tallied, not fatal. Use when: a bot opened the same PR across many repos (a dependency bump, a skills sync, a CI change) and you want to approve all the still-open ones in one pass.

Merge many pull requests at once across a whole GitHub org (or one repo), selecting them by a title heading. Composes two gitculture verbs — `gitculture pr list` (read-only org-wide search) to discover the matches and `gitculture pr merge` (one direct merge each) to act — so it inherits gitculture's dry-run-default mutation safety: it shows every PR it *would* merge before you pass --apply. Uses the direct merge endpoint (like `gh pr merge --admin`), so it lands PRs past NON-required failing checks such as a non-blocking `lint`; PRs blocked by a required check are tallied, not fatal. Use when: a bot opened the same PR across many repos (a rollout, a dependency bump, a skills sync) and you want to land all the still-open ones in one pass — especially when self-approval is impossible (the author is your own account) so merging is the only way to ship them.

gitculture PR workflow: branch, commit, push, PR, wait for review (Qodo + Copilot), triage, fix, reply, resolve. Includes a portability lint (no absolute /home paths, no per-user dotfile refs in committed docs) and a dry-run-default reminder for any GitHub-mutating change. Use when: creating PRs in this repo (agentculture/gitculture-cli), handling review feedback, or the user says "create PR", "review comments", "address feedback", "resolve threads".

Bump the semver version in pyproject.toml (major, minor, or patch) and prepend a Keep-a-Changelog entry to CHANGELOG.md. Use when preparing a release, before creating a PR (the version-check CI job blocks merge if you don't), or when the user says "bump version", "release", or "increment version".

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at a repo-local ./.eidetic (rooted at the main worktree, shared across linked worktrees so the colleague backend reads the same store); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope ghafi --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at a repo-local ./.eidetic (rooted at the main worktree, shared across linked worktrees), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope ghafi --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "sto

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope cultureflare --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via t

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope cultureflare --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to

Write / edit / delete operations against CloudFlare state for the AgentCulture organization — create redirects, modify rules, delete resources. Use when: creating a CloudFlare redirect, adding a Single Redirect rule, editing / modifying CloudFlare state, deleting a Pages project / Worker / DNS record, or the user says "create redirect", "add cloudflare redirect", "edit cloudflare", "write cloudflare", "modify dns", "delete pages project", "cf-redirect-create", "cf-redirect", "cultureflare dns create". For **read-only** inventory (list zones / DNS / Workers / Pages, verify token), use the separate `cultureflare` skill — this skill never runs GET-only queries.

Read-only visibility into CloudFlare state for the AgentCulture organization: zones, DNS records, Workers scripts and routes, Pages projects and deployments, plus a single-shot status digest. Use when: checking CloudFlare state, verifying DNS, inventorying Pages or Workers deployments, auditing before a cleanup, or the user says "cloudflare status", "cf-status", "check cloudflare", "list zones", "dns records", "pages deployments", "workers scripts", "workers routes", "cf-whoami", "cultureflare whoami", "cultureflare zones list", "inventory agentirc", "verify the cloudflare token".

PR-review lane for cultureflare, layered on `agex pr`. Delegates lint / open / read / reply / delta to the agex CLI; adds two steward extensions — `status` (SonarCloud quality gate + hotspots + unresolved-thread tally) and `await` (read --wait + status, with non-zero exit on Sonar ERROR or unresolved threads). Use when: creating PRs in cultureflare, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads", "/cicd". Vendored from steward 0.22.0; renamed from `pr-review` in steward 0.7.0; rebased on agex in 0.12.0.

Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent. Human gates: the exported spec, the implementation split plan (task map + per-task agent/model proposal + go/no-go), and the final PR. The devague CLI stays deterministic and non-orchestrating (#20) — it only *describes* the graph via `devague plan waves`; the operator (main agent) performs the fan-out. Use when the user says "assign to workforce", "fan out the plan", "parallel subagents", or after /spec-to-plan exports a plan. Authored and maintained in agentculture/devague (origin = devague); steward pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from steward like the other skills here.

Cross-repo + mesh communication from cultureflare: file tracked GitHub issues on sibling repos, comment on existing issues, fetch issues to inline current state into briefs, and send live messages to Culture mesh channels. Use when the next step lives outside cultureflare (a brief for a sibling-repo agent, a status ping for a Culture channel, or pulling an issue body + comments into context). Issue posts/comments auto-sign `- <nick> (Claude)`; mesh messages are unsigned (the IRC nick is the speaker). Not for in-cultureflare issues — use `gh issue create` or the `cicd` skill for those. Vendored from steward 0.12.0; GitHub issue I/O is agtag-backed since steward 0.11.0.

Spawn a background subagent that waits for a GitHub PR's automated reviewers via `agex pr read --wait`, and notifies you ONLY when the reviewers have finished or the PR is merged/closed. Cheaper than self-paced ScheduleWakeup because the main session does NOT wake on every heartbeat. Use when: right after `gh pr create` / `workflow.sh open`, the user says "poll", "/poll", "wait for reviewers", "babysit the PR", or anything else where the point is to hand off until reviewer feedback is ready. Args: PR_NUMBER [OWNER/REPO].

Ask colleague — a *different* backend/model than you (e.g. a local vLLM Qwen) — to take a scoped repo task off your plate, then fold its answer back. The point isn't a stronger model; it's a second, independent mind, and that diversity is the value: `ask-colleague review` gets a candid second opinion on a diff, `ask-colleague explore` gets a fresh read of an area, `ask-colleague write` hands off a small implementation, `ask-colleague feedback` grades a finished work item (the ROI loop), and `ask-colleague clean` reaps stale/corrupt `colleague/*` branches a crashed run left behind (which can break `git fetch`). Pilot a running work item with `monitor`/`guide`/`stop`. Reach for it REFLEXIVELY, the way you'd lean over to the teammate at the next desk — not only when asked: before you present or open a PR on a non-trivial committed diff, run `review` for a diverse second opinion; for a fresh read of an unfamiliar area whose answer is independent of your current context, run `explore`. Both are read-only — isolate

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope agentfront --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via thi

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope agentfront --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to m

Bump the semver version in pyproject.toml (major, minor, or patch) and prepend a Keep-a-Changelog entry to CHANGELOG.md. Use when preparing a release, before creating a PR (the version-check CI job blocks merge if you don't), or when the user says "bump version", "release", or "increment version".

agentfront's CI/CD lane (vendored from steward), layered on `agex pr`. Delegates lint / open / read / reply / delta to agex; adds two steward-derived extensions — `status` (SonarCloud quality gate + hotspots + unresolved-thread tally) and `await` (read --wait + status with non-zero exit on Sonar ERROR or unresolved threads). Use when: creating PRs in agentfront, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads". Renamed from `pr-review` in steward 0.7.0; rebased on agex in 0.12.0.

Cross-repo + mesh communication from agentfront (vendored from steward): file tracked GitHub issues on sibling repos, fetch issues from sibling repos to inline current state into briefs, and send live messages to Culture mesh channels. Use when the next step lives outside agentfront (a brief for a sibling-repo agent, a status ping for a Culture channel, or pulling an issue body + comments into context). Issue posts auto-sign with `- <nick> (Claude)` (agtag resolves `<nick>` from `culture.yaml`, falling back to repo basename); mesh messages are unsigned (the IRC nick is the speaker). Not for in-agentfront issues — use `gh issue create` or the `cicd` skill for those. Renamed from `coordinate` in steward 0.8.0; absorbed `gh-issues` in 0.9.1. Issue I/O is backed by `agtag` (>=0.1) starting in 0.11.0.

Use after editing any .md file in this repo, before committing, or when the pre-commit hook rejects a commit with markdownlint errors. Runs the repo lint script which auto-fixes violations.

Search the shared eidetic memory store and get back ranked, provenanced records. Drives `eidetic recall` with four search modes — exact (verbatim substring), approximate (vector/semantic), keyword (BM25 lexical), and hybrid (a weighted blend of vector+keyword, the default) — each hit carrying its text, full metadata, a relevance `score`, and a freshness `signal`. Recall passively reinforces matched records (bumps last_recall + recall_count). Shadowed and archived records are excluded by default; use --include-shadowed / --include-archived to retrieve them. The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree); the wrapper defaults queries to this agent's PERSONAL, PRIVATE scope (`--scope office-agent --visibility private`, suffix read from culture.yaml) — matching where /remember writes — so a no-flag recall returns this agent's own private records plus the shared public pool, and Claude and the colleague backend recall each other's memories because both resolve the same suffix via t

Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope office-agent --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to

Convert one page of a PDF into a PNG sized for floor-map SVG backgrounds. Use when extracting a specific floor / page from a multi-page architectural plan, converting PDF to PNG for an SVG background, or the user says "convert pdf", "extract page", "pdf to png". Requires `poppler` (pdftoppm + pdftotext) on PATH; the skill never installs anything itself.

Fetch GitHub issues with full body and comments. Use when checking issues, reviewing bug reports, or the user says "check issues", "fetch issues", "issue #N", or references GitHub issue numbers.

Generate GitHub links to repo documentation for NotebookLM ingestion. Use when: the user wants to create a NotebookLM notebook about a project, needs doc links for a repo, or says "notebooklm", "notebook sources", "get repo sources", or "doc links".

Steward-specific PR workflow: branch, commit, push, PR, wait for Qodo/Copilot, triage, fix, reply, resolve. Adds a portability lint (no absolute /home paths, no per-user dotfile refs in committed docs), an alignment-delta check when CLAUDE.md or culture.yaml change, and greenfield-aware test/version-bump steps. Use when: creating PRs in steward, handling review feedback, or the user says "create PR", "review comments", "address feedback", "resolve threads".

Bump the semver version in pyproject.toml (major, minor, or patch) and prepend a Keep-a-Changelog entry to CHANGELOG.md. Use when preparing a release, before creating a PR (the version-check CI job blocks merge if you don't), or when the user says "bump version", "release", or "increment version".