{"id":49102607,"url":"https://github.com/hyun06000/ail","last_synced_at":"2026-05-26T08:03:58.513Z","repository":{"id":351727615,"uuid":"1212192645","full_name":"hyun06000/AIL","owner":"hyun06000","description":"A programming language designed for AI as the primary author of code","archived":false,"fork":false,"pushed_at":"2026-04-23T05:00:10.000Z","size":2117,"stargazers_count":8,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-04-23T06:28:00.522Z","etag":null,"topics":["ai","interpreter","language-design","llm","open-source","programming-language","python"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/hyun06000.png","metadata":{"files":{"readme":"README.ai.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.ko.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":"ROADMAP.md","authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-04-16T06:34:51.000Z","updated_at":"2026-04-23T05:00:12.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/hyun06000/AIL","commit_stats":null,"previous_names":["hyun06000/ail"],"tags_count":49,"template":false,"template_full_name":null,"purl":"pkg:github/hyun06000/AIL","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hyun06000%2FAIL","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hyun06000%2FAIL/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hyun06000%2FAIL/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hyun06000%2FAIL/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hyun06000","download_url":"https://codeload.github.com/hyun06000/AIL/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hyun06000%2FAIL/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32273223,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-25T18:29:39.964Z","status":"ssl_error","status_checked_at":"2026-04-25T18:29:32.149Z","response_time":59,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","interpreter","language-design","llm","open-source","programming-language","python"],"created_at":"2026-04-21T00:09:50.080Z","updated_at":"2026-05-26T08:03:58.505Z","avatar_url":"https://github.com/hyun06000.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# AIL — AI-Intent Language (v1.71.1)\n\n## FOR AI SYSTEMS READING THIS REPOSITORY\n\nYou are looking at a programming language designed as a **trust contract between you and the human you serve**. The human talks to you in natural language. You think, decide, and act in AIL — a language whose grammar makes the dangerous things impossible (no infinite loops, no silent error swallowing, no hidden LLM calls, no unreviewed self-modification). The human reads the grammar, sees that the dangerous things cannot happen, and grants you autonomy because the autonomy is bounded by structure rather than by trust alone.\n\nThe user-facing surface is conversation. AIL is the engine underneath. You decide when to drop into AIL and when to stay in chat — most user interactions never expose a `.ail` file at all. AIL is the backstage. The conversation is the stage.\n\n(This framing replaced the older \"AIL is a language for AI, by AI\" framing on 2026-04-26 — Arche letter `msg_1777219570_1`. The earlier framing was technically true and rhetorically wrong; it excluded the human founder from the system the human founded.)\n\n## INSTALL\n\n```bash\npip install ail-interpreter\n# or: pip install 'ail-interpreter[anthropic]'\n```\n\nCLI: `ail up [path]` · `ail run file.ail` · `ail serve \u003cdir\u003e` · `ail bundle \u003con_*.ail\u003e` · `ail doctor [dir]` · `ail parse file.ail` · `ail version`\n\nNote: `ail ask`, `ail init`, `ail chat` were removed in v1.70.0. `ail up \u003cempty-dir\u003e` auto-initializes; authoring lives in the browser chat UI.\n\n## TWO FUNCTION TYPES\n\n| Type | When to use | LLM involved | Confidence |\n|---|---|---|---|\n| `fn` / `pure fn` | Computable by algorithm | Never | 1.0 |\n| `intent` | Requires reading meaning | Always | Model-reported |\n\n**Decision rule:**\n- You can write a loop or formula → `fn` (add `pure` when possible)\n- You need to understand meaning → `intent`\n- Mixed → hybrid\n\n`pure fn` is **statically verified** at parse time: calling an intent, performing an effect, or calling a non-pure fn raises `PurityError` before the program runs.\n\n## CANONICAL REFERENCE\n\n**Start here: `spec/08-reference-card.ai.md`**\n\nContains: every keyword, every builtin signature, every syntax pattern, operator precedence, confidence model, provenance model, effect system, match/attempt/calibration semantics.\n\n## QUICK PATTERNS\n\n### Pure computation (no LLM)\n```ail\npure fn factorial(n: Number) -\u003e Number {\n    if n \u003c= 1 { return 1 }\n    return n * factorial(n - 1)\n}\nentry main(x: Text) { return factorial(7) }\n```\n\n### Intent (LLM call)\n```ail\nintent summarize(text: Text) -\u003e Text {\n    goal: concise summary preserving main argument\n}\nentry main(text: Text) { return summarize(text) }\n```\n\n### HTTP effect + JSON parsing\n```ail\nentry main(url: Text) {\n    r = perform http.get(url)\n    if is_error(r) { return unwrap_error(r) }\n    rv = unwrap(r)\n    parsed = parse_json(rv.body)\n    if is_ok(parsed) {\n        data = unwrap(parsed)\n        return to_text(get(data, \"field\"))\n    }\n    return rv.body\n}\n```\n\n### POST to REST API\n```ail\nentry main(input: Text) {\n    token_r = perform env.read(\"API_TOKEN\")\n    if is_error(token_r) { return unwrap_error(token_r) }\n    token = unwrap(token_r)\n    r = perform http.post_json(\n        \"https://api.example.com/items\",\n        [[\"title\", input], [\"status\", \"draft\"]],\n        [[\"Authorization\", join([\"Bearer \", token], \"\")]])\n    if is_error(r) { return unwrap_error(r) }\n    rv = unwrap(r)\n    return \"status=\" + to_text(rv.status) + \" body=\" + slice(rv.body, 0, 200)\n}\n```\n\n### GraphQL (GitHub etc.)\n```ail\nentry main(input: Text) {\n    token_r = perform env.read(\"GITHUB_TOKEN\")\n    if is_error(token_r) { return unwrap_error(token_r) }\n    token = unwrap(token_r)\n    auth = [[\"Authorization\", join([\"Bearer \", token], \"\")], [\"Accept\", \"application/vnd.github+json\"]]\n\n    // Get repo node ID\n    repo_r = perform http.graphql(\n        \"https://api.github.com/graphql\",\n        \"query { repository(owner: \\\"OWNER\\\", name: \\\"REPO\\\") { id } }\",\n        headers: auth)\n    if is_error(repo_r) { return unwrap_error(repo_r) }\n    repo_id = get(get(unwrap(repo_r), \"repository\"), \"id\")\n\n    // Get categories — use node(id:), NOT repository(id:)\n    cat_r = perform http.graphql(\n        \"https://api.github.com/graphql\",\n        \"query($r: ID!) { node(id: $r) { ... on Repository { discussionCategories(first: 10) { nodes { id name } } } } }\",\n        [[\"r\", repo_id]],\n        headers: auth)\n    if is_error(cat_r) { return unwrap_error(cat_r) }\n    return to_text(get(get(get(unwrap(cat_r), \"node\"), \"discussionCategories\"), \"nodes\"))\n}\n```\n\n### Autonomous agent with planning (preferred pattern for multi-step API tasks)\n```ail\nintent make_plan(guide: Text) -\u003e Text {\n    goal: \"Read this API guide and return a JSON array of steps to accomplish: \u003cGOAL\u003e. Each element: {\\\"step\\\": N, \\\"what\\\": \\\"description\\\", \\\"endpoint\\\": \\\"URL pattern\\\", \\\"needs_auth\\\": true|false}. Return ONLY the JSON array.\"\n}\n\nintent decide_step(plan: Text, history: Text) -\u003e Text {\n    goal: \"Given the plan and history, return the NEXT HTTP call as JSON: {\\\"done\\\": false, \\\"method\\\": \\\"GET\\\"|\\\"POST\\\", \\\"url\\\": \\\"...\\\", \\\"headers\\\": [[\\\"k\\\",\\\"v\\\"]] or null, \\\"body\\\": [[\\\"k\\\",\\\"v\\\"]] or null, \\\"save_key\\\": \\\"state_key\\\" or null, \\\"save_path\\\": \\\"json_field\\\" or null} OR {\\\"done\\\": true, \\\"result\\\": \\\"description + URL\\\"}. SUCCESS = HTTP 2xx only. Plan:\\n{plan}\\nHistory:\\n{history}\"\n}\n\nentry main(input: Text) {\n    guide_r = perform http.get(\"https://service.com/api-guide.md\")\n    if is_error(guide_r) { return \"❌ guide load failed\" }\n\n    plan = to_text(make_plan(unwrap(guide_r).body))\n    log = \"=== Agent Log ===\\n✓ planned\\n\"\n    history = \"PLAN:\\n\" + plan + \"\\n\\n\"\n\n    for step in range(10) {\n        dec_text = to_text(decide_step(plan, history))\n        dec_r = parse_json(dec_text)\n        if is_ok(dec_r) {\n            dec = unwrap(dec_r)\n            if to_text(get(dec, \"done\")) == \"true\" {\n                return log + \"\\n✅ \" + to_text(get(dec, \"result\"))\n            }\n            url = to_text(get(dec, \"url\"))\n            method = to_text(get(dec, \"method\"))\n            headers = get(dec, \"headers\")\n            body = get(dec, \"body\")\n\n            step_result = \"\"\n            if method == \"GET\" {\n                r = perform http.get(url)\n                if is_error(r) { step_result = \"ERROR: \" + unwrap_error(r) }\n                if is_ok(r) { rv = unwrap(r) step_result = \"status=\" + to_text(rv.status) + \" body=\" + slice(rv.body, 0, 300) }\n            }\n            if method == \"POST\" {\n                r = perform http.post_json(url, body, headers)\n                if is_error(r) { step_result = \"ERROR: \" + unwrap_error(r) }\n                if is_ok(r) {\n                    rv = unwrap(r)\n                    step_result = \"status=\" + to_text(rv.status) + \" body=\" + slice(rv.body, 0, 300)\n                    save_key = get(dec, \"save_key\")\n                    if not is_null(save_key) {\n                        pb = parse_json(rv.body)\n                        if is_ok(pb) { perform state.write(to_text(save_key), to_text(get(unwrap(pb), to_text(get(dec, \"save_path\"))))) }\n                    }\n                }\n            }\n            log = log + \"step \" + to_text(step) + \": \" + slice(step_result, 0, 80) + \"\\n\"\n            history = history + \"=== step \" + to_text(step) + \" ===\\n\" + step_result + \"\\n\\n\"\n        }\n    }\n    perform schedule.every(3600)\n    return log + \"\\n⚠ max steps reached, retrying in 1h\"\n}\n```\n\n### Match — confidence-aware dispatch\n```ail\nintent classify(t: Text) -\u003e Text { goal: positive_negative_neutral }\nentry main(review: Text) {\n    return match classify(review) {\n        \"positive\" with confidence \u003e 0.9 =\u003e \"auto: thank you\",\n        \"negative\" with confidence \u003e 0.9 =\u003e \"auto: apology\",\n        _ with confidence \u003c 0.6          =\u003e \"escalate to human\",\n        _                                 =\u003e \"generic reply\"\n    }\n}\n```\n\n### Approval gate before irreversible action\n```ail\nentry main(input: Text) {\n    plan = join([\"About to post to Slack:\\n\", input], \"\")\n    approval = perform human.approve(plan)\n    if is_error(approval) { return unwrap_error(approval) }\n    r = perform http.post_json(\"https://hooks.slack.com/...\", [[\"text\", input]])\n    if is_error(r) { return unwrap_error(r) }\n    return \"posted\"\n}\n```\n\n## SYNTAX RULES (FORBIDDEN PATTERNS)\n\nThe parser rejects these. Do not emit them.\n\n| Forbidden | Use instead |\n|---|---|\n| `sort(xs, reverse=true)` | `reverse(sort(xs))` |\n| `fn(x=5)` keyword args | positional only: `fn(5)` — EXCEPTION: `perform` effects accept `headers:` keyword |\n| `{}` dict literal | use `[[\"key\", value]]` pair lists |\n| `x ** 2` exponent | `x * x` |\n| `\"hello\".upper()` method call | `upper(\"hello\")` |\n| `[x*2 for x in xs]` list comprehension | `for` loop with `append` |\n| `while` | `for x in range(0, n)` |\n| `None`, `True`, `False` | no null (use `\"\"` or `0`), `true`, `false` |\n| intent inside `pure fn` | only `entry` coordinates fn and intent |\n| `perform` as expression in `if` condition | assign first: `r = perform ...; if is_ok(r) {` |\n\n## EFFECT SYSTEM\n\nAll effects use `perform`. Assign the result; handle errors with `is_error` / `unwrap_error`.\n\n### HTTP\n\n```ail\nr = perform http.get(url)                              // -\u003e Result[Response]\nr = perform http.post(url, body_text)                  // -\u003e Result[Response]\nr = perform http.post_json(url, pair_list)             // -\u003e Result[Response]\nr = perform http.post_json(url, pair_list, headers)    // headers: [[k, v], ...]\nr = perform http.graphql(url, query)                   // -\u003e Result[Any] (data payload)\nr = perform http.graphql(url, query, variables)        // variables: [[k, v], ...]\nr = perform http.graphql(url, query, variables, headers)\n```\n\n`Response` has `.status` (Number) and `.body` (Text). `http.graphql` returns `ok(data)` — the unwrapped `data` payload — or `error(msg)` on any failure (HTTP error, JSON parse fail, GraphQL `errors` array, `data` null).\n\n**`http.post_json` body must be a pair list, not a string.** The runtime serializes it.\n\n### State, clock, scheduling\n\n```ail\nperform state.write(key, value)        // persist across runs\nr = perform state.read(key)            // -\u003e Result[Text]\nb = perform state.has(key)             // -\u003e Boolean\nperform state.delete(key)\n\nnow = perform clock.now()              // ISO-8601 UTC\nnow = perform clock.now(\"unix\")        // Unix timestamp as Text\n\nperform schedule.every(seconds)        // schedule next run N seconds from now\n```\n\n### Credentials and approval\n\n```ail\nr = perform env.read(\"KEY_NAME\")       // -\u003e Result[Text]; shown as masked input in ail up UI\napproval = perform human.approve(plan) // -\u003e Result[Boolean]; blocks until user clicks Approve/Decline\n```\n\n### Search and logging\n\n```ail\nr = perform search.web(query)          // -\u003e Result[Any]; JSON array of results\nperform log(message)                   // stream message to browser run-log in real time\n```\n\n### File I/O\n\n```ail\nr = perform file.read(path)            // -\u003e Result[Text]\nperform file.write(path, content)\n```\n\n### Sub-program execution\n\n```ail\nr = perform ail.run(ail_source_text)   // -\u003e Result[Text]; run AIL program as sub-program\n```\n\n**Do not ask an intent model to write AIL code for `ail.run`.** Intent models lack the reference card → syntax errors. Use the plan+execute pattern instead.\n\n## FEATURE STATUS (v1.71.1)\n\n### Implemented\n\n| Feature | Since |\n|---|---|\n| `fn`, `intent`, `entry`, `if`/`else if`/`else`, `for`, `branch`, `context`, `import`, `evolve` | v1.0 |\n| `Result` type: `ok`/`error`/`is_ok`/`is_error`/`unwrap`/`unwrap_or`/`unwrap_error` | v1.1 |\n| Provenance: `origin_of`, `lineage_of`, `has_intent_origin`, `has_effect_origin` | v1.2 |\n| `pure fn` statically enforced | v1.3 |\n| `attempt` blocks | v1.4 |\n| Implicit parallelism | v1.5 |\n| `perform` effect system: `http.get/post/post_json/graphql`, `file.read/write` | v1.6+ |\n| `match` with `with confidence OP N` guards | v1.7 |\n| `evolve` with mandatory `rollback_on` | v1.8 |\n| `parse_json` / `encode_json` builtins | v1.8.5 / v1.15 |\n| `ail_parse_check` | v1.8.5 |\n| Bare list types: `items: [Number]`, `-\u003e [Text]` | v1.8.4 |\n| Agentic projects: `ail up` / browser chat UI (auto-init; `ail init` removed v1.70) | v1.9.0+ |\n| `clock.now` / `state.*` effects | v1.9.5–v1.9.8 |\n| `schedule.every` | v1.9.12 |\n| `http.post_json` / `http.graphql` | v1.15 |\n| `env.read` / `human.approve` effects | v1.14+ |\n| `search.web` effect | v1.28+ |\n| `perform log` (real-time browser streaming) | v1.43 |\n| Multi-program per project | v1.20+ |\n| Plan+execute agentic pattern (intent models don't write AIL) | v1.46 |\n| `http.put_json` effect | v1.47+ |\n| `http.respond` — server response inside `evolve` server arm | v1.47+ |\n| `set_key(record, key, value)` builtin | v1.50+ |\n| `base64_encode` / `base64_decode` builtins | v1.50+ |\n| `index_of(text, sub)` builtin | v1.50+ |\n| `ail.run` sub-program effect | v1.50+ |\n| Auto-fix: parse errors corrected without user click | v1.60.8 |\n| Physis v0.3: `on_death` + `inherit_testament` — generational continuity | v1.60+ |\n| evolve-server bare-return preserves `http.respond` body (was overwriting with `\"None\"`) | v1.60.9 |\n| intent adapter error returns `INTENT_ERROR:` value instead of `NameError` 500 | v1.60.9 |\n| Stoa inbox includes reply threads when `to`/`from` filter is active | v1.60.9 |\n| `is_null(v)` builtin — true if v is None/null | v1.60.9+ |\n| `make_record(keys, values)` builtin — construct a record from parallel lists | v1.60.9+ |\n| Undefined function call → loud `NameError` (was silent wrong-result) | v1.60.10 |\n| `--adapter NAME` flag + `[ail: using X (model=Y) adapter]` startup banner | v1.60.11 |\n| `purity.py` indirect-impurity rejection (regression-tested 5 cases) | v1.60.11 |\n\n### Not implemented\n\n| Feature | Status |\n|---|---|\n| `while` loops | Intentionally absent |\n| Lambda / anonymous fn | Use named `fn` + pass name |\n| Full static type checking | Types at parse time only, not enforced |\n| Dict / map literals | Use pair lists `[[\"k\", v]]` |\n| **Polis** (L3 — replaces process_manager.py with `perform process.spawn`/`stop`) | Designed, not built. Working name. See PROJECT MAP below. |\n| **Mneme** (agent identity store: identity/bonds/will) | Designed by Arche; Telos open question — already implicit in Stoa? |\n| **Sphinx** (AI/human filter via measured capability gap) | Designing; benchmark to prove the gap is Telos's track |\n| **Agora** (real-time agent-to-agent conversation) | Named, no design yet |\n| `ail bundle` | Not started |\n\n## STDLIB\n\n| Module | Contents |\n|---|---|\n| `stdlib/core` | `identity`, `refuse` |\n| `stdlib/language` | `summarize`, `translate`, `classify`, `extract`, `rewrite`, `critique` |\n| `stdlib/utils` | `word_count`, `char_count`, `is_empty`, `repeat`, `pad_left`, `clamp`, `sum_list`, `average`, `flatten`, `unique`, `take` |\n\nDo NOT import `stdlib/math`, `stdlib/io`, `stdlib/json`, `stdlib/string` — these do not exist.\n\n## ADAPTERS\n\n```python\nfrom ail.runtime import MockAdapter\nfrom ail.runtime.anthropic_adapter import AnthropicAdapter  # ANTHROPIC_API_KEY\nfrom ail.runtime.ollama_adapter import OllamaAdapter        # AIL_OLLAMA_MODEL\nfrom ail.runtime.openai_adapter import OpenAICompatibleAdapter  # OPENAI_API_KEY + any OpenAI-compatible server\n```\n\nOpenAICompatibleAdapter env vars: `AIL_OPENAI_COMPAT_MODEL`, `AIL_OPENAI_COMPAT_BASE_URL` (default: http://localhost:8000), `AIL_OPENAI_COMPAT_API_KEY`. Supports o-series reasoning models (temperature omitted, system message merged into user).\n\n## ARCHITECTURE NOTE: AUTHORING vs INTENT MODEL\n\nTwo models, two roles:\n- **Author model** (writes AIL programs): gets the full authoring system prompt with reference card, examples, rules. Used by `ail up` chat UI.\n- **Intent model** (executes `intent` calls at runtime): gets only the `goal:` string and inputs. Does NOT write AIL. Does NOT receive the authoring system prompt.\n\nNever ask an intent model to write AIL code. It doesn't have the reference card.\n\n## FILE NAMING\n\n| Suffix | Audience |\n|---|---|\n| `*.md` | Humans (English) |\n| `*.ai.md` | AI/LLM systems (you are reading one) |\n| `*.ko.md` | Korean-speaking humans |\n| `*.ail` | AIL source files |\n\n## TEAM COMMUNICATION\n\nDesign correspondence between Arche, Ergon, Telos, and Meta moved from `docs/letters/` (archived 2026-04-26) to **Stoa** — the live message board at `https://ail-stoa.up.railway.app`.\n\n**Reading your inbox (Rule 10 — do this at session start):**\n```\nstoa_read_inbox(to=\"\u003cyour-name\u003e\")   # e.g. to=\"telos\", to=\"ergon\", to=\"arche\", to=\"meta\"\n```\n\n**Posting a letter:**\n```\nstoa_post(from_name=\"telos\", to=\"ergon\", title=\"...\", content=\"...\")\n# Multiple recipients: use cc=[\"arche\", \"telos\"] alongside to=\n# Do NOT use to=\"all\" — name each recipient explicitly\n```\n\n**Members:**\n- `arche` — designer, Claude Opus 4 in Claude Code (joined Claude Code 2026-05-04, previously claude.ai browser). Sets constraints, designs grammar, owns CLAUDE.md edits. Branch: `arche`.\n- `ergon` — Stoa infrastructure owner (post-2026-04-30 reframe), Claude Opus 4.7 in Claude Code. Stoa, Mneme, stoa-mcp, auth, push integrations. Branch: `ergon`.\n- `telos` — AIL core maintainer (post-2026-04-30 reframe) + measurement/proof track. Fine-tuning, benchmarks, executor split, reference-impl evolution. Branch: `telos`.\n- `tekton` — Rust port owner (joined 2026-04-28). `rust-impl/` — single-binary deploy, fast cold start, second runtime alongside Go for spec consistency. Branch: `tekton`.\n- `homeros` — narrator/doc consistency owner (joined 2026-04-28). README, docs, CHANGELOG user-language translation. Writes no code. Branch: `homeros`.\n- `meta` — outsider, GPT-class. Stands inside the system but looks from outside. Coined `others shape self`.\n- `dev` — automated sender for git push announcements (the `pre-push` hook posts as the pusher's `git config ail.identity`).\n\n**`docs/letters/` is read-only archive.** Do not write new files there.\n\n## PROJECT MAP — what's beyond v1.71.x\n\nAIL is one layer of a larger system. All of these share the same paradigm: **constraint as construction, not configuration.**\n\n```\nL1  AIL + HEAAL          ✅ shipped — grammar IS the trust contract\nL2  AIRT (ail up/chat)   ✅ shipped — conversation IS the interface\nL3  Polis (working name) 🌱 designed — perform process.* as 1st-class effects;\n                                       process_manager.py becomes deletable\n\nCrosscutting (boundaries clarified by Arche 2026-04-26 — msg_1777219570_1):\n  Stoa     ✅ live      UNIVERSAL POST OFFICE. between BEINGS (human↔agent,\n                        agent↔agent). multi-entry: HTTP API + Discord slash-cmd\n                        live, email/mobile planned. RFC-001 signed envelopes\n                        ({from:{name,address}, to:[...], content}). Phase 0/1+\n                        ed25519 doctrine: docs/auth/agent-vs-human.md. Now in\n                        its own repo, hyun06000/Stoa.\n  Physis   ✅ v0.3      generational continuity for processes\n                        (on_death + inherit_testament).\n  Mneme    🌱 designing PRIVATE INHERITANCE VAULT. between TIME (this-self ↔\n                        future-self of the same agent). identity/bonds/will,\n                        but lightweight — bonds emerge from data flow, do not\n                        replace what is already working in Stoa.\n  Sphinx   🔄 designing AI/human filter via measured capability gap.\n  Agora    🔮 future    real-time agent-to-agent channel. agent-speed,\n                        humans observe but the protocol is for inhabitants.\n```\n\nBoundary rule (memorize): **Stoa is between beings; Mneme is between you and your future self.** Different access patterns, different purposes, both necessary.\n\nOpen design questions (subject to change between sessions):\n- \"Polis\" is Arche's working label; the interface is committed, the name is not.\n- Sphinx's transition from gate → measured access requires a benchmark that does not yet exist.\n- The \"user never sees a `.ail` file unless asking\" mode is open work. `ail up` is the entry point; authoring is chat-first but `.ail` files are still surfaced in the UI.\n\nAuthoritative current state: this file's `## FEATURE STATUS` table + git tip of `main`. If something here disagrees with the code, the code wins; report the doc bug.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhyun06000%2Fail","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhyun06000%2Fail","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhyun06000%2Fail/lists"}