ASCII diagrams grounded in the README and docs.

8.1 Interpreter Pipeline

   source.kei
        │
        ▼
  ┌──────────────┐   ANTLR grammar
  │  Lexer/Parser│───────────────────┐
  │  (ANTLR)     │                   │
  └──────────────┘                   ▼
                             ┌──────────────┐
                             │ Syntax Tree  │
                             └──────┬───────┘
                                    ▼
                          ┌─────────────────────┐
                          │  C Interpreter Core │
                          │  evaluate tree +    │
                          │  manage runtime     │
                          └─────────┬───────────┘
                                    ▼
        ┌──────────────────────────────────────────────┐
        │  RUNTIME STATE                               │
        │  • suspended generator frames (yield/proceed)   │
        │  • caller ↔ generator channel (transmit/receive)│
        │  • exception injection (disrupt)                │
        │  • scheduler (async/await, defer, sleep)        │
        └──────────────────────────────────────────────┘
                                    │
                                    ▼
                          declare(...) → output
   Run modes:  REPL  `keikaku`   |   file  `keikaku script.kei`

8.2 Keyword Map (themed → conventional)

  Keikaku            Conventional
  ───────            ────────────
  designate / :=  →  variable declaration / assignment
  declare         →  print
  foresee         →  if
  alternate       →  else if
  otherwise       →  else
  cycle while     →  while loop
  cycle through   →  for-each loop
  cycle from..to  →  range loop
  protocol        →  function
  sequence        →  generator
  yield / proceed →  yield / next
  delegate        →  yield from
  transmit/receive→  send / (yield-received value)
  disrupt         →  throw-into-generator
  attempt/recover →  try / catch
  anomaly         →  unchecked / deliberate-deviation block

8.3 Generator Lifecycle

   gen := counter(0)          ┌───────────────┐
        │                     │  CREATED      │
        ▼                     └───────┬───────┘
   proceed(gen) ──────────────────────▼
                              ┌───────────────┐   run to next yield
                              │  RUNNING      │───────────────┐
                              └───────┬───────┘               │
                                      ▼                       │
                              ┌───────────────┐               │
                              │  SUSPENDED    │◀──────────────┘
                              │  (at yield)   │
                              └─────┬───┬─────┘
             transmit(gen,v) ───────┘   └─────── disrupt(gen,err)
             (receive() gets v)                 (raise at suspension;
                                                 attempt/recover may
                                                 catch & continue)
                                      │
                                      ▼  no more yields
                              ┌───────────────┐
                              │  DONE         │
                              └───────────────┘

8.4 Delegation Flow (delegate)

  sequence maintask():
      yield "start"  ─────────────▶ start
      delegate subtask() ──┐
                           ▼
                    sequence subtask():
                        yield "a" ──▶ a
                        yield "b" ──▶ b
      yield "end"    ─────────────▶ end

  Consumed stream:  start → a → b → end
  (delegate accepts generators OR lists)

8.5 Async / Await Flow

  await main()
      │
      ▼
  async protocol main():
      user  := await fetch_user(1) ───┐   suspend until resolved/yielded
                                      ▼
                              ┌────────────────┐
                              │ event loop /   │  defer(delay, fn, ...)
                              │ scheduler      │  sleep(ms)
                              │ (shares gen    │  resolve(value) → promise
                              │  suspension)   │
                              └────────────────┘
                                      │ resume
      posts := await fetch_posts(user)◀┘
      declare(user, posts)

  await suspends on BOTH promises and generator yields
  → async is a scheduling layer over the coroutine runtime

8.6 Error Handling Model

  ┌─────────────────────────────────────────────────┐
  │ attempt:                                        │
  │     result := divide(10, 0)   ── fails ──┐      │
  │     declare(result)                      │      │
  │ recover error:  ◀────────────────────────┘      │
  │     declare("Deviation handled:", error)        │
  └─────────────────────────────────────────────────┘

  Generator-directed:   disrupt(gen, err) ──▶ raised at gen's
                        suspension point ──▶ caught by in-gen
                        attempt/recover ──▶ generator continues

  Escape hatch:         anomaly:  runs regardless of standard checks