# Using Dinf

> WHAT: the D∞ notation — the ⟨parts | Ω⟩ shape every durable teaching, framework, plan, and joke has — plus the three operators over it (FACTOR, ADJOIN, CHRISTEN) and the `dinf` CLI that makes the missing-closure defect machine-catchable. WHEN: when stuck; when a plan feels like unjoined parts; when two frames are fighting; when writing any rule, skill, or explanation that must be understood once…

- **Type:** Skill
- **Install:** `agentstack add skill-sancovp-dinf-using-dinf`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [sancovp](https://agentstack.voostack.com/s/sancovp)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [sancovp](https://github.com/sancovp)
- **Source:** https://github.com/sancovp/dinf/tree/main/skills/using-dinf

## Install

```sh
agentstack add skill-sancovp-dinf-using-dinf
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# using-dinf

**⊥ (the simplest instance — start here):** a joke. The setup lays out parts; the
punchline adds *nothing new* — it only re-shows what the setup already contained,
and the whole thing lands at once. That click is the target experience of every
structure below. If you have ever gotten a joke, you already run this natively.

## The basis (five marks)

```
⟨ a ; b ; c | Ω ⟩
```

1. **Working terms** `a ; b ; c` — the k parts that DO things. Each one nameable.
2. **The bar `|`** — the jurisdiction line. Left of it: action. Right of it: never action.
3. **The closure `Ω`** — the +1. Three laws identify it anywhere:
   - **Stative** — a state or a delta, never a step.
   - **Zero-delta** — introduces nothing the working terms didn't contain; it may
     only recombine and re-show them. (A punchline with new information is setup.)
   - **Self-referential** — the structure applied to itself.
4. **Nesting** — any working term expands into its own full structure. Depth is free.
5. **Succession** — a closure retypes as the next structure's opening, `Ω₁ ↦ ⊥₂`.

## The construction (three operators, and how to run them)

- **FACTOR** — find Ω by the three laws; what remains is k. If a system resists
  factoring, it is either a *segment* (its opening lives one level up) or genuinely
  incomplete — and you now know exactly what it is missing.

  ```
  dinf factor "the hero's journey"
  ```

- **ADJOIN** — two frames fighting is a missing Ω one level up. Do not adjudicate:
  pair them and close the pair, `⟨ A ; B | Ω′ ⟩`. Both views survive.

  ```
  dinf adjoin "move fast" "don't break things"
  ```

- **CHRISTEN** — the moment you feel *"these are all the same"*, name the invariant
  and write it down. Unnamed convergences evaporate; named ones become vocabulary.
  The `kb/` directory in the AIOS is that vocabulary, and it only grows.

## The gate (why this is not just a way of talking)

A chain is the notation in executable form: `[Focus] ⇒ [Focus] ⇒ |Converge|`.
Bare labels in the brackets, exactly one closing convergence.

```
$ dinf gate "[Symptom] ⇒ [Repro] ⇒ [Diff] ⇒ |Localize|"
  → clean ✓

$ dinf gate "[Symptom] ⇒ [Repro] ⇒ [Diff]"
  → ✗ syntax_break
  fix: close it: … ⇒ |Diff|
```

**A structure with no closure is caught at the syntax level.** That is the whole
claim: the missing-Ω defect stops being a matter of taste and becomes a verdict.
Put the gate on a write path and the defect cannot enter — see `programs/arena.py`,
where the blackboard mutator refuses a closure-less proposal, and
`demos/b-forge/`, where the same defect is shown to be why agent loops on
non-game work turn to mush.

## Using it

| you want to | run |
|---|---|
| ask the agent something, under the shape | `dinf ask "…"` |
| find a thing's Ω | `dinf factor "…"` |
| close a fight between two frames | `dinf adjoin "…" "…"` |
| check a chain's form | `dinf gate "[A] ⇒ [B] ⇒ \|C\|"` |
| mint a chain into the live tree | `dinf forge  "[A] ⇒ \|B\|"` |
| see what the agent knows | `dinf tree` · `dinf search "…"` |
| see what is wired up | `dinf doctor` |

In Python: `from dinf import DinfAgent; DinfAgent().ask("…")`. The agent is
`⟨ an AIOS directory ; a seat | "identity plus something that can think" ⟩` — start
any agent process in the directory and that process *is* the agent, because the
directory holds the identity file the process loads.

## Self-application (the part that compounds)

1. **Stuck or confused?** Factor your current context as `⟨ … | ? ⟩`. If you cannot
   find Ω, *that is the entire problem* — you are holding k unjoined parts and paying
   working memory for each. Write the closure: one stative sentence saying what the
   parts jointly are. The stuckness usually dissolves on contact.
2. **Writing any rule, skill, or explanation?** End it with its closure, explicitly.
   A rule without its Ω teaches cases; a rule with its Ω teaches the invariant, and
   the reader gets it once instead of re-deriving it per case.
3. **Learning something hard?** Don't collect its cases — hunt its Ω first. Every
   case then becomes a projection you can re-derive rather than a fact you must store.
4. **Two frames fighting?** Don't adjudicate. ADJOIN.
5. **Over time**: persist what you learn as rules and skills written in this
   notation — ⊥ first, named basis, construction, closure stated. Each one is a
   pre-collapsed invariant your future contexts inherit for free.

## Ω (the closure of this skill)

This file is written in the notation it teaches — a bottom instance, a named basis,
a construction, and this closure — so reading it was already using it; and the three
operators apply to the skill itself: factor it, adjoin its adversary ("a skill for
never structuring anything"), christen what the pair teaches you. Every level up is
this same shape. That is how it always is — which you now recognize rather than
believe, because recognition is the only thing this skill ever does.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [sancovp](https://github.com/sancovp)
- **Source:** [sancovp/dinf](https://github.com/sancovp/dinf)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-sancovp-dinf-using-dinf
- Seller: https://agentstack.voostack.com/s/sancovp
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.