# Skills library

> Agent-readable SKILL.md packs (resolver, core, capture, reflect, review), routing table, cross-skill chaining, and harness-neutral memory injection.

- Repository: superdesigndev/loopany
- GitHub: https://github.com/superdesigndev/loopany
- Human docs: https://grok-wiki.com/public/docs/superdesigndev-loopany-97bd9ab97ae8
- Complete Markdown: https://grok-wiki.com/public/docs/superdesigndev-loopany-97bd9ab97ae8/llms-full.txt

## Source Files

- `skills/loopany-resolver/SKILL.md`
- `skills/loopany-core/SKILL.md`
- `skills/loopany-capture/SKILL.md`
- `skills/loopany-reflect/SKILL.md`
- `skills/loopany-review/SKILL.md`
- `injections/resolver-memory.md`
- `INSTALL_FOR_AGENTS.md`

---

---
title: "Skills library"
description: "Agent-readable SKILL.md packs (resolver, core, capture, reflect, review), routing table, cross-skill chaining, and harness-neutral memory injection."
---

The loopany CLI does not load or execute skills — judgment lives in markdown under `skills/` in the cloned repo (conventionally `~/loopany-src/skills/`), while `loopany init` copies only kind definitions from `skills/loopany-core/kinds/` into `$LOOPANY_HOME/kinds/`. Agents read `loopany-resolver` first, follow its routing table to the right pack, then call deterministic `loopany` commands documented in each skill.

## Architecture

```mermaid
flowchart TB
  subgraph harness["Agent harness"]
    MEM["Host memory file<br/>CLAUDE.md / AGENTS.md / /memory add"]
    AGT["Agent session"]
  end

  subgraph repo["~/loopany-src (repo)"]
    INJ["injections/resolver-memory.md"]
    RES["skills/loopany-resolver/SKILL.md"]
    CORE["skills/loopany-core/"]
    CAP["skills/loopany-capture/"]
    REF["skills/loopany-reflect/"]
    REV["skills/loopany-review/"]
    MIG["skills/migrations/"]
  end

  subgraph workspace["$LOOPANY_HOME (workspace)"]
    KINDS["kinds/*.md"]
    ART["artifacts/"]
    REFS["references.jsonl"]
  end

  subgraph cli["loopany CLI"]
    OPS["artifact / refs / trace / followups / doctor"]
  end

  INJ --> MEM
  MEM --> AGT
  AGT -->|"Read at task end"| RES
  RES --> CORE & CAP & REF & REV
  CORE --> OPS
  CAP --> OPS
  REF --> OPS
  REV --> OPS
  init["loopany init"] --> KINDS
  OPS --> ART & REFS
```

<Note>
Skills are **provider- and harness-neutral**: any agent that can read files from disk (or a catalog mirror of the repo) can follow the same packs. No API keys, hosted skill registry, or model-specific runtime is required — only a stable path to `loopany-resolver/SKILL.md` and the injection snippet.
</Note>

## Pack inventory

| Pack | Path | Role |
|------|------|------|
| **Resolver** | `skills/loopany-resolver/SKILL.md` | First read on any loopany interaction; bootstrap gate + routing table + chaining rules |
| **Core** | `skills/loopany-core/SKILL.md` | Artifact CRUD routing; kind playbooks under `kinds/`; conventions under `conventions/` |
| **Capture** | `skills/loopany-capture/SKILL.md` | Post-work capture: event→kind routing, quality gate, subagent dispatch |
| **Reflect** | `skills/loopany-reflect/SKILL.md` | Pattern discovery → `learning` / `skill-proposal`; accept/reject apply flow |
| **Review** | `skills/loopany-review/SKILL.md` | Parameterized daily / weekly / monthly reviews; frequency detail in `references/` |
| **Migrations** | `skills/migrations/v*-to-v*/SKILL.md` | Agent-executable schema migration narratives + standalone `scripts/` |

Each operational pack uses Anthropic Agent Skills frontmatter (`name`, `description` with explicit triggers). The runtime never parses these files; they are instructions for the agent only.

## Bootstrap gate

Before any skill-specific work, the resolver requires an active mission:

```bash
loopany artifact list --kind mission --status active
```

No active mission → run `ONBOARDING.md` and **stop**. No capture, reflect, or review skill fires without a mission-backed workspace.

## Resolver routing table

Match the trigger, read the target `SKILL.md`, then act. When two rows match, read both — they chain.

| Trigger | Target pack | Read |
|---------|-------------|------|
| Any artifact CRUD (`create` / `get` / `list` / `append` / `status` / `set`) | core | `skills/loopany-core/SKILL.md` |
| Substantive work just ended (PR shipped, incident resolved, decision made) | capture | `skills/loopany-capture/SKILL.md` |
| `reflect` / `what have we learned` / ≥3 tasks done / writing `learning` or `skill-proposal` | reflect | `skills/loopany-reflect/SKILL.md` |
| `accept <proposal-slug>` / `reject <proposal-slug>` / review proposals | reflect | `skills/loopany-reflect/SKILL.md` |
| `what's due today` / daily check-in / session start | review (daily) | `skills/loopany-review/SKILL.md` + `references/daily.md` |
| `what's slipping` / weekly check / workspace health | review (weekly) | `skills/loopany-review/SKILL.md` + `references/weekly.md` |
| Mission drift / structural questions / monthly cadence | review (monthly) | `skills/loopany-review/SKILL.md` + `references/monthly.md` |
| Choosing a relation verb / `loopany refs add` | core conventions | `skills/loopany-core/conventions/relations.md` |
| Note vs kind vs domain decision | core conventions | `skills/loopany-core/conventions/taxonomy.md` |

### Disambiguation rules

- **Most specific wins** — e.g. `create a task` → core, not capture.
- **Conventions stack** — core does not exempt `refs add` from the six canonical relation verbs.
- **When in doubt, ask** before committing an artifact.

## Core kind routing

After loading core, route to the kind playbook under `$LOOPANY_HOME/kinds/` (copied from `skills/loopany-core/kinds/` at init). Read the kind file — schema **and** `§ Playbook` — before create or modify.

| Trigger | Kind playbook |
|---------|---------------|
| Committing to work, `[change]` / `[incident]` | `kinds/task.md` |
| Writing `## Outcome`, flipping task status | `kinds/task.md § Playbook` |
| Noticed something, can't act now | `kinds/signal.md` |
| Dismissing / upgrading a signal | `kinds/signal.md § Playbook` |
| Writing a learning | `kinds/learning.md` |
| Writing a skill-proposal | `kinds/skill-proposal.md` |
| Mission create/update | `kinds/mission.md` |
| Brief / person / journal | respective kind file |
| Anything else | `kinds/note.md` |

Pass `--slug` whenever the artifact will be cited in `[[wiki-links]]` or graph edges. Omit only for batch ingestion.

## Cross-skill chaining

Some workflows intentionally span packs in sequence:

| Chain | Flow |
|-------|------|
| **Capture → Core** | Capture picks the kind; core's playbook governs creation |
| **Capture → Reflect** | After ≥3 captures in a session, suggest reflect |
| **Reflect → Core** | Reflect writes learnings/proposals via core playbooks |
| **Review → Core** | Review dispatches each surfaced item to its kind playbook |
| **Review → Reflect** | Weekly review with ≥3 resolutions → suggest reflect |

```text
Session end ──► resolver-memory (inject) ──► resolver ──► capture?
                                              │
                    ┌─────────────────────────┼─────────────────────────┐
                    ▼                         ▼                         ▼
                  core                    reflect                     review
                    │                         │                         │
                    └──────────── loopany CLI (artifacts + graph) ──────┘
```

Skill-to-skill references in markdown bodies use `[[<path>/SKILL.md]]` (path relative to the linking file, always ending in `SKILL.md`). Bare `[[slug]]` in artifact bodies is reserved for artifact IDs and becomes `mentions` edges — not skill links.

## Harness-neutral memory injection

The CLI has no skill loader. Persistent trigger discipline comes from appending one block into the host's memory primitive.

<Steps>
<Step title="Locate the canonical snippet">

`injections/resolver-memory.md` — instructs the agent to **Read** `~/loopany-src/skills/loopany-resolver/SKILL.md` at the end of every user-requested task, before the final reply.

</Step>
<Step title="Append idempotently (coding CLIs)">

<CodeGroup>
```bash title="Claude Code"
grep -q "loopany skill resolver" ~/.claude/CLAUDE.md 2>/dev/null || \
  cat ~/loopany-src/injections/resolver-memory.md >> ~/.claude/CLAUDE.md
```

```bash title="Codex / AGENTS.md"
TARGET="$HOME/AGENTS.md"
grep -q "loopany skill resolver" "$TARGET" 2>/dev/null || \
  cat ~/loopany-src/injections/resolver-memory.md >> "$TARGET"
```
</CodeGroup>

</Step>
<Step title="Register on agent platforms">

For hosts with a `/memory add` primitive, register the same file contents (collapse newlines if the platform rejects multiline values).

</Step>
<Step title="Verify without self-query">

```bash
grep -l "loopany skill resolver" ~/.claude/CLAUDE.md ~/AGENTS.md 2>/dev/null
test -f ~/loopany-src/skills/loopany-resolver/SKILL.md && echo "RESOLVER present"
```

Start a **fresh** session and ask where the resolver lives. A correct answer without file search means injection worked.

</Step>
</Steps>

<Info>
`git pull` on `~/loopany-src` updates skill **content** without re-running injection — the memory block only holds a pointer to the resolver path. A future `loopany doctor` check for resolver registration is planned but not implemented yet.
</Info>

## Cadence and recurring packs

| Cadence | Pack | Typical trigger |
|---------|------|-------------------|
| Daily | `loopany-review` | `loopany followups --due today`; session start |
| Weekly | `loopany-review` | overdue sweep + `loopany doctor` + parking lots |
| Weekly | `loopany-reflect` | fresh outcomes; pattern thresholds |
| Monthly | `loopany-review` | mission alignment + structural drift |

On coding CLIs (Claude Code, Codex), durable platform cron is unreliable — default to **session-boundary** prompts instead of silent cron registration. Agent platforms with durable cron may register jobs silently; record job IDs for re-install audits. See `INSTALL_FOR_AGENTS.md` Step 4 for the full decision tree.

## Skill evolution (never direct edits)

Agents **must not** edit files under `skills/` except through an accepted `skill-proposal` artifact:

1. Reflect writes `learning` (+ optional `skill-proposal` citing evidence).
2. User accepts or rejects via reflect's proposal-apply flow.
3. On accept: apply only the described change, append `## Outcome` to the proposal, `loopany artifact status … accepted`, git-commit target + proposal together.
4. `changeType: add` requires `## Skill draft` and `## Resolver entry` so new packs are reachable from the routing table.

Rejected proposals record reasons in `## Outcome` so reflect does not re-suggest the same rule.

## Conventions sub-packs

| File | Use when |
|------|----------|
| `conventions/relations.md` | `loopany refs add --relation` — six canonical verbs: `led-to`, `addresses`, `mentions`, `supersedes`, `follows-up`, `cites` |
| `conventions/taxonomy.md` | Choosing `note` vs new kind vs new domain (default: `note`) |

`relation` remains an open registry in code, but synonyms fragment `refs` / `trace` queries — conventions live in skills, not TypeScript (`src/core/references.ts`).

## Migrations as skills

Schema jumps ship under `skills/migrations/v<from>-to-v<to>/` with a readable `SKILL.md` and ordered `scripts/*.ts`. `loopany migrate` discovers migrations; the **agent** reads the skill and runs scripts — the CLI does not execute them. This keeps transforms separable from the thin harness.

## Verification

| Check | Command / artifact |
|-------|-------------------|
| Resolver on disk | `test -f ~/loopany-src/skills/loopany-resolver/SKILL.md` |
| Injection landed | `grep -l "loopany skill resolver" ~/.claude/CLAUDE.md …` |
| Workspace health | `loopany doctor` |
| End-to-end skill behavior | `./test/skill-regression.sh` (symlinks core/reflect/review/capture into a temp Claude skills dir; 10 scenarios via `claude -p`) |

<Warning>
Skill regression requires the `claude` CLI, an API key, and ~5 minutes for a full pass. It validates artifact routing and capture/review/reflect behavior — not resolver injection into user memory files.
</Warning>

## Anti-patterns (resolver-level)

- Acting without reading the resolver routing table first
- Skipping a pack's anti-patterns section (failure modes live there)
- Trusting session memory over re-reading skills (skills change via proposals)
- Writing artifacts without reading the target kind playbook
- Exposing loopany vocabulary (`kind`, `slug`, CLI flags) to end users during normal conversation — translate in user-facing text per `INSTALL_FOR_AGENTS.md`

## Related pages

<CardGroup>
<Card title="Installation" href="/installation">
Clone, link CLI, inject resolver memory into your agent host.
</Card>
<Card title="Workspace setup" href="/workspace-setup">
`loopany init`, bundled kinds, onboarding, cadence, and `doctor`.
</Card>
<Card title="Capture workflow" href="/capture-workflow">
Event→kind routing, quality gate, and subagent dispatch.
</Card>
<Card title="Reflect workflow" href="/reflect-workflow">
Evidence gathering, pattern thresholds, learnings, and proposals.
</Card>
<Card title="Periodic review" href="/periodic-review">
Daily, weekly, and monthly review scopes and closure gate.
</Card>
<Card title="Self-improvement loop" href="/self-improvement-loop">
Task outcomes → reflect → accept/reject → git-backed skill diffs.
</Card>
<Card title="Kinds and validation" href="/kinds-and-validation">
Workspace kind files, Zod schemas, and immutable write rules.
</Card>
</CardGroup>