---
title: Self-Healing Autopoietic Shell
emoji: 🔁
colorFrom: indigo
colorTo: purple
sdk: static
pinned: false
license: other
license_name: use-only-no-modify-no-sell
license_link: LICENSE
---

# Self-Healing Autopoietic Shell

A shell function that learns from its own failures and doesn't fail the same way twice.

## What it does

```
run command → fails → ask for a fix → persist the fix → retry → succeed
```

The next time that exact command is run, the learned fix is applied automatically before the command itself — no failure, no prompt. The knowledge lives in a plain text file (`p`) that you can copy to any other machine to transfer what this shell has learned.

- **Zero infrastructure.** Pure POSIX shell. No database, no ML model, no network calls.
- **Transferable cognition.** `p` is just `command=fix` lines. `scp p otherhost:~/p` and the other machine inherits every fix you've ever taught this one.
- **Self-modifying, not self-executing.** It never guesses a fix on its own — a human (or another process) supplies it once, and the loop remembers it forever after.

## The pattern (41 bytes)

```sh
f(){ $@||{read x&&bash -nc$x&&echo$x>>p&&eval$x&&f"$@";};}
```

This is the minimal, unapologetically golfed core: run `$@`; if it fails, read a replacement command, sanity-check it parses, log it to `p`, eval it, and recurse. It's the idea in its smallest possible form — fragile on purpose, to show the mechanism with nothing hidden.

## The hardened version (`src/f.sh`)

The golfed version above breaks on quoting, doesn't distinguish between different failing commands, and recurses instead of looping. `src/f.sh` is a POSIX-portable version used in production (it's what boots inside [AdaptiveOS](../adaptiveos)):

```sh
f() {
    FIX=""
    while IFS= read -r line; do
        case "$line" in
            "$*="*) FIX="${line#"$*="}" ;;
        esac
    done < p
    until { eval "$FIX" 2>/dev/null; "$@"; }; do
        printf '\n[LEARN] "%s" failed. Enter a fix: ' "$*"
        read -r n
        [ -n "$n" ] || return 1
        echo "$*=$n" >> p
        FIX="$n"
    done
}
```

Differences from the 41-byte original:
- Looks up the fix **keyed by the exact command**, so `p` can hold fixes for many different failing commands, not just the last one.
- Uses `until`/loop instead of self-recursion.
- Applies the learned fix *proactively* on every subsequent call, not just after a fresh failure.

## Usage

```sh
. src/f.sh
f cat /etc/myapp.conf
# [LEARN] "cat /etc/myapp.conf" failed. Enter a fix (blank to give up):
# > echo "port=8080" > /etc/myapp.conf
```

Note the fix isn't a *replacement* for the command — it's a **precondition** that runs immediately before the original command is retried. `f` always re-runs the exact command you asked for; the fix's job is to make the environment one where that command now succeeds (create a missing file, export a variable, start a service, etc.).

Run it again later — even in a new shell, as long as `p` is in the working directory — and it applies the fix silently.

## Why "autopoietic"

[Autopoiesis](https://en.wikipedia.org/wiki/Autopoiesis) (Maturana & Varela) describes systems that produce and maintain themselves through their own operation — a cell doesn't have external code telling it how to be a cell; the process of living *is* the process of continuously rebuilding itself. `f()` is a toy version of that idea applied to a shell: the artifact that results from running it (`p`, the accumulated fixes) changes how the function itself behaves on the next call. The shell is, in a small way, writing its own patches.

See `docs/DESIGN.md` for more on the mechanism and its limits.

## Try it

Open `index.html` (or this Space) for an interactive in-browser simulation of the learn/fix/retry loop — no shell required.

## Files

- `src/f.sh` — the hardened, sourceable implementation
- `index.html` — interactive browser demo
- `docs/DESIGN.md` — design notes, the autopoiesis framing, known limitations
- `test/test_f.sh` — automated test of the learn → persist → auto-apply cycle