{"path":"research/bend-and-deliberus/bend2-status-report-2026-10-26.md","content":"*Saved verbatim on 2026-10-26: the report of a research helper (Sonnet) asked, on his request to explore Bend \"with an\nopen mind\" (*\"Bend might possibly even be able to help with meta-argumentation, enforcing rulings and many other things\"*),\nwhat changed in Bend 2 since the 2026-09-29 report beside this file, and how it could serve strict inferences,\nmeta-argumentation and rulings as laws. The helper read and did not run anything; the hands-on trial the same night is in\n`spin-2026-10-26/`, and what follows from both is `../bend-and-deliberus.md` § 9.*\n\n---\n\n# Bend 2 for Deliberus: status and fit, as of 2026-10-26\n\nI wrote no project files. I cloned bendlang/bend (commit 295e996, 2026-10-23) into the session scratchpad at /private/tmp/claude-501/-Users-fredrikbranstrom-dotfiles/c8b4f19b-adf4-45e6-8f94-17f0960e19e0/scratchpad/bend/repo and read it there. **I did not install or run Bend.** Every \"works\" below is the project's statement or a third party's, not my test. Where I give my own reading, I mark it \"My inference\".\n\nRead depth is tagged per source in the list at the end (FULL TEXT / PARTIAL / SNIPPET). Links in the text point to the numbered sources there.\n\n## 0. Headline\n\n- Since 2026-09-17, bendlang/bend has shipped 32 releases, v2.0.8 to v2.0.39. Five came after 2026-09-29: v2.0.35 (10-03), .36 (10-07), .37 (10-13), .38 (10-20), .39 (10-23) [1][2]. There were 273 commits since 09-29 (page count of the commits API at per_page=1) [3]. The repo has about 24,245 stars and 116 open issues [3].\n- The proof layer is real and actively used by outsiders. The project also admits bugs in it, and a stream of soundness-type bugs was reported and fixed in October (section 4).\n- **There is no public proof automation.** The README says \"no tactics or proof search\" [4]. BendAI, the proving agent, is a paid, proprietary \"thin harness around models from Anthropic, OpenAI and others\". The page says SupGen \"will arrive in future updates\" and the API \"opens within the coming days\" [13]. I found nothing public that uses SupGen or NeoGen.\n- I found **no public use of Bend 2 for argumentation, knowledge graphs, Datalog/ASP-style reasoning or rule engines**, and no comparison with clingo. Closest are statute-as-claims (lajur) and an agent-authorization kernel (issue #1847), both in section 3.\n- I found **no Python FFI**. A Python target exists only as an open proposal with an unmerged branch (issue #1827) [20]. Section 5 has the working routes.\n\n## 1. Releases, install, prerequisites\n\n**Latest:** v2.0.39, published 2026-10-23T21:40Z. Release assets: darwin-arm64, darwin-x64, linux-arm64, linux-x64 tarballs. The darwin-arm64 one is 25,805,589 bytes [1].\n\n**Install, exactly as the v2.0.39 release notes and install.sh give it** [1][5]:\n```\ncurl -fsSL https://bend-lang.com/install.sh | sh\n```\n- Alternatives named in the notes: `brew install bendlang/bend/bend` or `nix profile install github:bendlang/bend` [1].\n- I could not find the tap repo bendlang/homebrew-bend (404). However, Homebrew's API lists a formula `bend` at stable 2.0.39 from the GitHub tag tarball, bottle \"all\", with a dependency on `bun` [6]. So the Homebrew build runs the TypeScript implementation under bun.\n- The install script downloads bend-2.0.39-darwin-arm64.tar.gz from GitHub releases and checks a sha256 hard-coded in the script (darwin-arm64 d4aaef68...3f5d83a). It installs under ~/.bend, needs no sudo and edits no shell file. It prints a PATH line to add [5].\n- The installed bend asks bend-lang.com once a day for the latest version, sending version, OS and CPU type. `BEND_NO_TELEMETRY=1` turns that off [5].\n\n**macOS arm64: yes.** There is a darwin-arm64 asset and the README says \"Bend works best on the back-end, on Linux or macOS\" [4]. Windows is unsupported (WSL works) [4].\n\n**Prerequisites**\n- Checking and proofs need nothing beyond the bend binary. This is my reading of install.sh [5] and the CLI source [7]; I have not run it.\n- A native binary (`-o file`) needs clang 14+; `!` (GPU) needs clang 19+ plus Metal or CUDA 12 [4].\n- **`--verdict` needs Lean v4.34.0.** On first use bend builds the kernel from bend2/bendtt.lean with `lean` and `leanc`, via elan or the PATH, and caches it under ~/.bend/bendtt/. Alternatively set `$BENDTT` to a prebuilt kernel. Source: safe.ts, lines about `kernel_bin()` [8]. A third-party skill repo confirms: \"The first --verdict of a bend release builds the kernel with Lean\" [9].\n\n**Standalone checking of a LAWS/PROOF file: yes.** Commands from the CLI source and guide [7][10]:\n- `bend PROOF.bend` checks it and runs `main` if there is one. It prints `ALL PROOFS CHECK` or `SOME PROOFS FAIL`. The guide calls this \"the gate\". bend refuses a PROOF.bend that sits beside a LAWS.bend without importing it [10].\n- `bend FILE --check-only` checks the file and its imports and runs nothing [7].\n- `bend FILE --verdict` rechecks with the Lean-proven kernel. It prints `ALL PROOFS CHECK` only if no def relies on `@unsafe` or foreign code [7][10].\n- `bend FILE -o out.bendtt` writes the translation the kernel reads, \"so read it to confirm a law\" [10].\n- Exit codes: 0 on pass; SOME PROOFS FAIL exits 1 (shown in issues #1328 and #1716) [18][19].\n\n**Breaking changes in the last month (churn risk).** v2.0.37 turned Nat into a plain JS number across the JS boundary (a Nat above 2^53 stops the run). v2.0.38 changed the `+RTS` runtime-options syntax, JS constructor tags and `TCP.send` residue [1][2].\n\n**Corporate posture after 09-29.** A digest of Taelin's 09-29 post (secondary, Digg; the X post itself returned HTTP 402) says [11]:\n- The kernel and compiler are to be rewritten in Bend.\n- \"Live λ contraction\" is called the largest expressivity gap relative to Lean.\n- funext and univalence are planned, possibly self types too.\n- A $20M raise is being prepared, not closed.\n- BendHub is live, with named, versioned packages.\n\n## 2. What a law and a proof look like\n\nAll of the following is copied from the repo at 295e996.\n\n**Law and proof, from the README and guide** [4][10]:\n```python\n# LAW: \"for every x, x plus 0 equals x\"\nlaw add_zero:\n  for x: Nat\n  {Nat.add(x, 0n) == x : Nat}\n\ndef add_zero(x):\n  match x:\n    case 0n:\n      {==}\n    case 1n+p:\n      %add_zero(p) : {1n+Nat.add(p, 0n) == 1n+_ : Nat}\n      {==}\n```\n\n**The guide's description of the mechanism** [10]:\n- No tactics. A proposition is a type, and a proof is a def of that type.\n- `{a == b : T}` is equality. `{==}` proves it when both sides compute to the same term.\n- Matching refines the goal. A recursive call is the induction hypothesis.\n- `%e : P` rewrites with `e : {a == b : T}`. `P` is the goal with `_` marking `b`.\n- `exs y: T` in a law asks for a witness, returned as `(y, proof)`.\n- `?name` prints the goal and `?TODO` leaves it open.\n- A law with no def is an open claim.\n- `{a != b : T}` is `{a == b : T} -> Empty`.\n- A `match e:` with no cases closes a branch where `e : Empty`.\n- Base has `Equal.sym`, `Equal.trans` and `Equal.cong`.\n\n**Propositional and first-order connectives are encoded, not built in** [12]. These are from bend2/base.bend:\n```python\ndef Pair(-A: Type, -B: Type) -> Type:        # conjunction\n  Sigma<&1, &1, A, _ => B>\ndef Exists(-A: Type, -B: @-x: A -> Type) -> Type:\n  Sigma<&1, &1, A, B>\ndef Or(-A: Type, -B: Type) -> Type:          # disjunction\n  Either<&1, &1, A, B>\n```\nNegation is `... -> Empty`. A claim can also be a type-valued def, as in `def IsEven(n: Nat) -> Type` [10].\n\n**Short inductive-type examples**\n- Order as evidence, from demos/proof_insertion_sort/main.bend [14]:\n```python\ndef LE(a: Nat, b: Nat) -> Data:\n  match a b:\n    case 0n b0:\n      Unit\n    case 1n+a1 0n:\n      Empty\n    case 1n+a1 1n+b1:\n      LE(a1, b1)\n```\n- Laws stated by a human, from the same demo's LAWS.bend [14]:\n```python\nlaw sort_sorted:\n  for +xs: List<&2, Nat>\n  Sort.Sorted(Sort.sort(xs))\n\nlaw sort_perm:\n  for +x  : Nat\n  for +xs : List<&2, Nat>\n  {Sort.count(x, Sort.sort(xs)) == Sort.count(x, xs) : Nat}\n```\nThe proofs of these two are about 80 lines in PROOF.bend, by induction on the list.\n- An existential law with a witness, from demos/proof_numerics/LAWS.bend [14]:\n```python\nlaw divmod_ok:\n  for +n: Nat\n  for +m: Nat\n  exs  q: Nat\n  exs  r: Nat\n  {(q, r) == Num.divmod(n, 1n+m) : Nat & Nat} & {True{} == (r < 1n+m : Nat) : Bool} & {n == Num.add(r, Num.mul(q, 1n+m)) : Nat}\n```\n- A typed-expression optimizer, from demos/proof_typed_eval/LAWS.bend [14]. `Expr<t>` is indexed by type, so ill-typed terms cannot be built:\n```python\nlaw opt_sound:\n  for  t: TE.Ty\n  for  e: TE.Expr<t>\n  {TE.eval(t, TE.opt(t, e)) == TE.eval(t, e) : TE.Val(t)}\n```\n- A small proven fact in Base about max [12]:\n```python\nlaw Nat.max_ge_l:\n  for +a: Nat\n  for +b: Nat\n  {Nat.is_ge(Nat.max(a, b), a) == True{} : Bool}\n```\nBase defines `Nat.min` and `Nat.max` and proves only `max_ge_l` and `max_ge_r`. I found no proven `min` laws in Base.\n\n**Numbers: a constraint for the Deliberus rulings** [4][12]\n- Numeric types are Nat, U32 and F32 only.\n- F32 is axiomatic: \"nothing about floating point can be proven\".\n- `grep` found no Rational or signed-integer type in base.bend. Issues show U64 and F64 were merged in September (#1057, #1058, closed).\n- `Nat.sub` is truncated subtraction.\n\n**Automation: none public.**\n- README: \"Bend has no tactics or proof search\" [4].\n- BendAI is the paid agent. Its page says SupGen ships \"in future updates\" and does not say what the current version does beyond calling public models [13].\n- Community `lawcheck` (bendcheck) is random testing of laws, not proof search. It \"tests every law in a LAWS.bend before you prove\" [15].\n- Community lemma libraries cover Nat, List and Bool facts [16].\n- A 2026-10-25 issue offers 41 proven U32/Nat laws, written with AI agents and cross-checked by an independent Lean model (#1850) [17].\n\n## 3. Uses in logic, verification, rules; comparisons\n\n**Nothing found** for argumentation, knowledge graphs, Datalog/ASP or clingo comparisons, or business-rule engines. Searches covered GitHub repos and code, web search and the issue tracker. The Reddit r/bendlang page was not fetchable, so coverage of Reddit is nil. The Hacker News Algolia query returned only one post after 09-29: a 1-point, 0-comment repo link [21].\n\n**Closest relevant examples, all small and new:**\n- **Statute as claims.** `elianiva/lajur` (created 2026-10-24) states Indonesian traffic law as named claims, one per requirement, each proved. Example: `law a_motorway_is_100: { M.speed_limit(M.Motorway{}) == 100 : U32 }`. A note says \"A statute also defines terms, sets numbers, allocates powers\" and that each category gets its own representation. PARTIAL read [22].\n- **Agent authorization.** Issue #1847 (2026-10-24, open) reports 8 verified theorems for capability attenuation, replay rejection and a Pareto \"never promotes a regression\" gate. It also lists three ergonomics complaints: no symmetric rewrite, no computed scrutinee in `match`, and mixed-literal operator typing [23].\n- **Spec-gap demonstration.** `LeeeeT/winning-is-possible` (2026-10-25) shows 7 ways to reach the win screen of Bend's own demo while `bend PROOF.bend` still says ALL PROOFS CHECK. Its summary: \"every fact the page relies on has to be either a law, or not relied on\" [24]. This is about the laws not covering the app, not a checker bug.\n- **Test-first workflow.** `nohzafk/bend-ldd` is an agent skill: state laws, falsify them, prove them, then mutate the core and check the law's proof fails [9].\n- **JSON schema checker.** `nohzafk/bend-schema` is a schema validator whose checker is proved, with a TypeScript front end. Errors carry `proved: true|false` [25].\n- **Behavior of IO shells.** Issue #1784 (open) asks for a pure interpreter so laws can state exit status and stdout [26].\n\n**Comparisons with Lean/Agda/Idris/Rocq:** nothing independent beyond these.\n- The Nezk gist and the Hacker News threads were read in the 09-29 report, so I do not repeat them.\n- The project's own paper says Bend is not optimal for proofs: it has no tactics, only a single universe with `Type : Type` and negative datatypes. Consistency is argued from affinity of live code, with the dead fragment inconsistent. The kernel is about 4,000 Lean lines, no `sorry`, no extra axioms. The claims table covers confluence, subject reduction, progress, halts, empty, sound, consistent and adequate. Two parts are unverified: the parser, and the TypeScript translation into the kernel [27].\n- Theorem 8 (\"adequacy\"): a closed live proof of `a == b` implies `a` and `b` are convertible [27]. This is what makes a proved law mean what it says about closed values.\n- Digital Applied's 2026-09-18 article compares Bend with Dafny and Verus only. It calls the benchmarks the project's own and unreproduced [28].\n- Taelin posted (X, snippet only) that Fable 5 proved Bend 2's consistency in Lean. The same thread concedes a typo or mismatch with the real implementation could undermine it [29].\n- The $10k bounty (v2.0.32, 09-27): produce a file that passes `--verdict` and contains a proof of Empty. Unsafe code, FFI and the non-kernel compiler are out of scope [30]. A later post says it is still up. I found no report of anyone claiming it [29].\n- Depth for all three X-sourced items is SNIPPET, because X returned HTTP 402 to my fetch.\n\n**My inference on fit to the three questions (not sourced):**\n- *(a) Strict inferences and chains of them.* Bend checks a supplied derivation. It does not search for one, so it is a certificate checker, not a replacement for clingo's grounding and solving. As a complement, a rule system could be a datatype of derivations plus a function that checks one, with laws about it. Nothing public does this.\n- *(b) Meta-argumentation.* The typed-evaluator demo is the closest pattern: types indexed by a \"type of thing\" make ill-formed objects unrepresentable [14]. That fits well-formedness of arguments and rule governance. Nothing public covers argumentation itself.\n- *(c) Rulings as laws.* This is the strongest fit. A law about a fold's weakest step is the same shape as the sort demo, and `Nat.min`/`Nat.max` exist. The obstacle is numeric: no proof-friendly fractions or reals. The range rule `[max(0,a+b-1), min(a,b)]` would need integers scaled, for example to thousandths. Also, a law only covers the Bend functions it mentions. Production Python code is covered only if the core itself is Bend and Python calls it.\n\n## 4. Limits and bugs reported since launch\n\n**The project's own limitation list**, copied from the README [4]:\n- \"Everything is annotated and nothing is inferred, so code is verbose.\"\n- \"Bend has no tactics or proof search; proving theorems takes extra effort.\"\n- Values are affine: closures and arrays cannot be shared. Recursion must terminate. Mutual recursion is not allowed. There is no if-then-else; a branch is a match on True and False. Computed matches (`match f(x)`) are unsupported.\n- \"F32 is axiomatic: nothing about floating point can be proven.\"\n- \"The compiler (not kernel) is 99% AI-written and not yet fully audited.\"\n- \"The checker has no proof and may have bugs; `--verdict` uses a proven kernel.\"\n- \"`--verdict` checks the translated terms, the parser and translation into the kernel are not proven.\"\n- \"Laws are proven about Bend's semantics. The backends can still differ, for example in F32 NaN.\"\n- No type classes, no traits; \"Base is small\"; no JSON/regex/TLS; \"No test framework and no documentation beyond the guide.\"\n\n**Soundness-type bug reports in issues (all primary, GitHub)**\n- #1001 (fixed 2026-09-24): one `@unsafe` law fill in a file PROOF.bend imports silently proved every law, with a clean \"All terms check.\" [31].\n- #1716 (closed 2026-10-19) and #1328 (still open, same family): a bare constructor name as a match pattern on an imported datatype becomes a catch-all binder, so a false law checks. Those two issues are shown in sections [18][19].\n- #1482 (closed within 7 hours on 2026-10-11): a reporter saw false equalities accepted through glued `0n+` precedence and a misaligned `case`. I did not read how it was resolved, so I do not know whether it was judged a bug [32].\n- About a dozen `--verdict` \"mismatch\" issues, closed in the 2.0.37/38 notes. Example: #1138, \"The BendTT kernel rejects what bend2 accepts\" [33]. Still open: #1623 (reused proof after reconstructing a constructor with a function field) and #1483 (template lambda capturing a run-time value inside a type: out of scope for the kernel, though bend2 accepts it).\n- #1593/#1555/#1535: the kernel runs out of fuel on proofs the everyday checker accepts in 0.06 s; closed, but the project's bend2.dev note still lists \"can run out of fuel\" as a limit [34].\n- #848 (closed 2026-09-20): a proof could not reuse a hypothesis, so theorems over abstract structures were out of reach. Closed, but I read only the first half (lines cut at 600 characters). The 09-29 roadmap still lists contraction as the largest gap [11][35].\n- #1418 (closed): a claim-text gap. The kernel's consistency claim covers the literal empty enum `<>`, while the surface `Empty` is a sigma over it; the issue argues it is still uninhabitable [36].\n- WONTFIX lists intended design choices, including that the checker skips dead code and that it is not optimal: \"some terms are exponential or overflow\" [37].\n\n**Independent performance reports** are as in the 09-29 note (4x slower than Rust for the pixel-art port; 62 s vs 57 s native build) [38]. I found no new independent benchmarks since, and no independent checker benchmark. Issue #1781 (open, 2026-10-20) reports a tiled matmul about 4x slower than hand-written CUDA.\n\n**Security:** #1836 (fixed in 2.0.39) said `bend --publish` could upload files outside the project via foreign imports. #1837 (open) says pinned imports loaded from a BEND_LIB cache skip hash verification [1].\n\n## 5. Calling Bend 2 from Python\n\n- **No FFI from Python, and no Python target yet.** The README lists Lua, Luau and Python as planned targets [4]. Issue #1827 (open, 2026-10-22, by AFDudley) proposes `bend main.bend -o main.py` and importable `lib.pym`. It cites an unmerged branch with 22 commits. Its own test table shows 863 pass, 3 fail and 854 dropped on CPython 3.12, with \"every number below is preliminary\" and an open conflict with the repo's gate [20].\n- **Targets that exist:** C, Metal, CUDA, JavaScript (JS runs on one core) [4].\n- **Working routes for a Python service (my inference, built from the sources):**\n  1. **Subprocess to a compiled binary or `bend file.bend args`.** Build with `bend core.bend -o core` (needs clang 14+). Runtime options go between `+RTS` and `-RTS` since 2.0.38; `IO.args` reads the rest [1][10]. Output goes through `IO.print`. Bend has no JSON library, so you would pass your own text format or add a foreign import [4].\n  2. **JS module.** `bend file.bend -o f.mjs` writes an ES module of the non-IO defs. A JS file can call them with constructors as `{$: \"Name\", field: value}` and Nat as a number, and an Array argument is updated in place [10]. Python would then need a Node or Bun worker (process or socket) between it and the module. `bend-emit` generates typed named exports and `.d.mts` declarations from a Bend core. It says \"The generated JavaScript is not independently proved\" [39]. The Homebrew formula pulls in bun [6].\n  3. **Run Bend as a checker only.** Python calls `bend PROOF.bend --verdict` in CI, so proofs gate commits but nothing runs inside the service. This avoids the numeric and startup costs but gives no runtime link between the proved function and the Python one.\n- **The JS target has costs for a long-lived service:** it is one core, and the repo has a recent run of JS-lane string slowness fixes [2].\n- **Direction of foreign calls:** Bend imports C or JS effect files (`import \"./x.c\"`). The reverse is the JS-host route above [10]. `Process.run` lets Bend start external programs (section 1 notes; fixed in 2.0.39) [1].\n\n## 6. Not found / not verified\n\n- No installed run, no timing, and no test that `bend PROOF.bend` works on this Mac. I did not execute anything downloaded.\n- No Reddit content (fetch blocked) and no X post bodies (HTTP 402); the Taelin items rest on search-result snippets or the Digg digests.\n- No public SupGen or NeoGen proof search; BendAI's API is described as opening \"within the coming days\" with no date [13].\n- No Bend 2 use for argumentation, knowledge graphs, Datalog, ASP or rule engines, and no comparison with clingo.\n- No independent audit of bendtt.lean, and no independent checker benchmark since launch.\n- I did not read bend.ts (the checker) or the parser.\n- I did not read the full text of the bounty rules.\n\n## Sources (read depth)\n\n1. https://github.com/bendlang/bend/releases (v2.0.39 body FULL TEXT, v2.0.38 body FULL TEXT, v2.0.37 PARTIAL, release list via API FULL TEXT)\n2. https://github.com/bendlang/bend/blob/main/CHANGELOG.md PARTIAL (head, 2.0.39 to 2.0.37)\n3. https://api.github.com/repos/bendlang/bend (and /commits?since=2026-09-29) FULL TEXT (metadata only)\n4. https://github.com/bendlang/bend (README) FULL TEXT\n5. https://bend-lang.com/install.sh FULL TEXT\n6. https://formulae.brew.sh/api/formula/bend.json FULL TEXT (fields read)\n7. https://github.com/bendlang/bend/blob/main/bend2/main.ts PARTIAL (usage table, verdict function, lines 25-84, 896-1000)\n8. https://github.com/bendlang/bend/blob/main/bend2/safe.ts PARTIAL (kernel_bin and kernel_check, lines 1598-1700)\n9. https://github.com/nohzafk/bend-ldd PARTIAL (README first 4,500 characters)\n10. https://github.com/bendlang/bend/blob/main/guide/GUIDE.md FULL TEXT\n11. https://digg.com/ai/aw2uscoc PARTIAL (WebFetch summary of Taelin's 2026-09-29 post)\n12. https://github.com/bendlang/bend/blob/main/bend2/base.bend PARTIAL (types, Pair/Exists/Or, Nat.min/max, law list)\n13. https://bend-lang.com/bendai and https://bend-lang.com/ PARTIAL (WebFetch summaries)\n14. https://github.com/bendlang/bend/tree/main/demos (proof_insertion_sort, proof_numerics, proof_typed_eval LAWS.bend FULL TEXT; PROOF.bend PARTIAL; main.bend of insertion_sort PARTIAL)\n15. https://github.com/Yazington/bendcheck PARTIAL (README first 4,500 characters)\n16. https://github.com/caiodomingues/bend-lemmas PARTIAL (README first 2,800 characters)\n17. https://github.com/bendlang/bend/issues/1850 FULL TEXT\n18. https://github.com/bendlang/bend/issues/1328 PARTIAL (first 90 lines, cut at 900 characters)\n19. https://github.com/bendlang/bend/issues/1716 FULL TEXT\n20. https://github.com/bendlang/bend/issues/1827 PARTIAL (first 90 lines, cut at 900 characters)\n21. https://news.ycombinator.com/item?id=50237170 SNIPPET (Algolia hit: title, date, 1 point, 0 comments)\n22. https://github.com/elianiva/lajur PARTIAL (README first 4,500 characters)\n23. https://github.com/bendlang/bend/issues/1847 FULL TEXT\n24. https://github.com/LeeeeT/winning-is-possible PARTIAL (README first 4,500 characters)\n25. https://github.com/nohzafk/bend-schema PARTIAL (README first 2,800 characters)\n26. https://github.com/bendlang/bend/issues/1784 FULL TEXT\n27. https://github.com/bendlang/bend/blob/main/bend2/docs/BendTT/main.typ PARTIAL (Theorem 8 and mechanization, lines 940-985 and 1060-1110; grep elsewhere)\n28. https://www.digitalapplied.com/blog/prove-ai-written-code-correct-verification-tools PARTIAL (WebFetch summary)\n29. https://x.com/VictorTaelin/status/2074190998394052926 and https://x.com/VictorTaelin/status/2104240438127288652 and https://x.com/VictorTaelin/status/2111917179730022589 SNIPPET (search-result snippets only; fetch returned HTTP 402)\n30. https://digg.com/ai/ddckjtpg PARTIAL (WebFetch summary of the bounty announcement)\n31. https://github.com/bendlang/bend/issues/1001 FULL TEXT\n32. https://github.com/bendlang/bend/issues/1482 FULL TEXT\n33. https://github.com/bendlang/bend/issues/1138 PARTIAL (first 70 lines)\n34. https://bend2.dev/notes/what-is-bend2/ PARTIAL (WebFetch summary, page updated 2026-10-20; operator unclear)\n35. https://github.com/bendlang/bend/issues/848 PARTIAL (first 70 lines, cut at 600 characters)\n36. https://github.com/bendlang/bend/issues/1418 PARTIAL (first 90 lines, cut at 900 characters)\n37. https://github.com/bendlang/bend/blob/main/WONTFIX.txt PARTIAL (first 60 lines)\n38. https://akitaonrails.com/en/2026/09/19/new-ai-language-just-released-bend-2/ and https://digg.com/ai/yt56pevk SNIPPET (via search results; already covered FULL TEXT in the 09-29 note)\n39. https://github.com/nohzafk/bend-emit PARTIAL (README first 2,800 characters)\n"}