wao 0.40.0 → 0.40.1

package/cjs/create.js

@@ -478,16 +478,21 @@ var main = /*#__PURE__*/function () {
           t.fail("Failed to install dependencies");
           return _context5.a(2);
         case 15:
+          t.sub("root dependencies installed");
+          _context5.n = 16;
+          return exec("cd \"".concat(appdir, "/dashboard\" && npm install"));
+        case 16:
+          t.sub("dashboard dependencies installed");
           t.done();
           hbWarnings = [];
           if (!(hbMode !== "skip")) {
-            _context5.n = 26;
+            _context5.n = 27;
             break;
           }
           t.step("Detecting HyperBEAM environment");
-          _context5.n = 16;
+          _context5.n = 17;
           return detectHBEnv();
-        case 16:
+        case 17:
           _yield$detectHBEnv = _context5.v;
           deps = _yield$detectHBEnv.deps;
           missing = _yield$detectHBEnv.missing;
@@ -522,24 +527,24 @@ var main = /*#__PURE__*/function () {
           t.sub(".env.hyperbeam \u2192 CWD=".concat(hbCwd));
           t.done();
           if (!(hbMode === "clone")) {
-            _context5.n = 23;
+            _context5.n = 24;
             break;
           }
           t.step("Cloning HyperBEAM");
           t.sub("tag: ".concat(HB_TAG));
-          _context5.n = 17;
+          _context5.n = 18;
           return exec("cd \"".concat(appdir, "\" && git clone --depth 1 --branch ").concat(HB_TAG, " ").concat(HB_REPO, " HyperBEAM"), {
             maxBuffer: 50 * 1024 * 1024,
             timeout: 600000
           });
-        case 17:
+        case 18:
           t.done();
           if (!(deps.erl && deps.rebar3 && missing.length === 0)) {
-            _context5.n = 22;
+            _context5.n = 23;
             break;
           }
           t.step("Compiling HyperBEAM (with genesis-wasm)");
-          _context5.p = 18;
+          _context5.p = 19;
           envParts = [];
           if (deps.gcc) {
             envParts.push("CC=gcc-".concat(deps.gcc), "CXX=g++-".concat(deps.gcc));
@@ -548,46 +553,46 @@ var main = /*#__PURE__*/function () {
             envParts.push("CMAKE_POLICY_VERSION_MINIMUM=3.5");
           }
           envPrefix = envParts.join(" ");
-          _context5.n = 19;
+          _context5.n = 20;
           return exec("cd \"".concat(appdir, "/HyperBEAM\" && ").concat(envPrefix, " rebar3 as genesis_wasm compile"), {
             maxBuffer: 50 * 1024 * 1024,
             timeout: 600000
           });
-        case 19:
+        case 20:
           t.sub("genesis-wasm device compiled");
           t.done();
-          _context5.n = 21;
+          _context5.n = 22;
           break;
-        case 20:
-          _context5.p = 20;
+        case 21:
+          _context5.p = 21;
           _t4 = _context5.v;
           t.fail("Compile failed — check .env.hyperbeam and run manually");
-        case 21:
-          _context5.n = 23;
-          break;
         case 22:
+          _context5.n = 24;
+          break;
+        case 23:
           if (missing.length > 0) {
             t.step("Skipping compilation (missing dependencies)");
             t.sub("Run 'cd HyperBEAM && rebar3 compile' after installing dependencies");
             t.done();
           }
-        case 23:
+        case 24:
           // Generate wallet in HyperBEAM directory
           hbWalletDir = (0, _path.resolve)(appdir, hbCwd);
           t.step("Generating HyperBEAM wallet");
           hbArweave = _arweave["default"].init();
-          _context5.n = 24;
+          _context5.n = 25;
           return hbArweave.wallets.generate();
-        case 24:
+        case 25:
           hbJwk = _context5.v;
-          _context5.n = 25;
+          _context5.n = 26;
           return hbArweave.wallets.jwkToAddress(hbJwk);
-        case 25:
+        case 26:
           hbAddr = _context5.v;
           (0, _fs.writeFileSync)((0, _path.resolve)(hbWalletDir, ".wallet.json"), JSON.stringify(hbJwk));
           t.sub("address: ".concat(hbAddr));
           t.done();
-        case 26:
+        case 27:
           if (withFrontend) {
             t.step("Setting up frontend");
             t.sub("Vite + React + wao/web");
@@ -634,16 +639,16 @@ var main = /*#__PURE__*/function () {
             console.log("    ".concat(dim("$"), " yarn deploy src/counter.lua --wallet .wallet.json"));
             console.log();
           });
-          _context5.n = 28;
+          _context5.n = 29;
           break;
-        case 27:
-          _context5.p = 27;
+        case 28:
+          _context5.p = 28;
           _t5 = _context5.v;
           t.fail(_t5.message);
-        case 28:
+        case 29:
           return _context5.a(2);
       }
-    }, _callee5, null, [[18, 20], [7, 27]]);
+    }, _callee5, null, [[19, 21], [7, 28]]);
   }));
   return function main() {
     return _ref5.apply(this, arguments);

package/cjs/workspace/.claude/agents/builder.md

@@ -35,8 +35,10 @@ Read these before building:
    - **aos**: Write AOS scripts in `src/` with input validation
    - **aos-test**: Write in-memory tests in `test/`, iterate until `yarn test` passes
    - **aos-integration**: Write HyperBEAM tests, iterate until they pass
-   - **device**: Write Erlang module, compile with `rebar3 as genesis_wasm compile`
-   - **device-test**: Write eunit tests, iterate until `rebar3 eunit` passes
+   - **module-lua**: Write standalone Lua module in `custom-lua/`, no AOS framework
+   - **module-wasm**: Write Rust WASM64 module in `custom-wasm/`, `#![no_std]`
+   - **module-test**: Write HyperBEAM integration tests for custom modules
+   - **device**: Write Erlang device + inline eunit tests in same `.erl` file, compile with `rebar3 as genesis_wasm compile`, iterate until `rebar3 eunit` passes
    - **device-integration**: Write WAO SDK integration tests against running HyperBEAM
    - **frontend**: Write React components with `wao/web`
    - **frontend-test**: Write vitest tests, iterate until they pass

package/cjs/workspace/.claude/skills/build/SKILL.md

@@ -31,7 +31,20 @@ Full build orchestrator. Sequences through plan → build → test → validate
 
 ### 1. Check for existing plan (resume support)
 
-Read `plan.md` and `tasks.json` at the project root. If both exist and tasks.json has `"current_step"`, resume from that step — skip to the first task with `"status": "pending"` or `"in_progress"`.
+Read `plan.md` and `tasks.json` at the project root. If both exist and tasks.json has `"current_step"`, resume:
+
+1. Find the first task with `"status": "in_progress"` — resume debugging that task immediately.
+2. If no `in_progress` task, find the first task with `"status": "pending"` — start it.
+3. If ALL tasks are `"done"`, **re-verify every test task** by running its tests:
+   - `aos-test` → `yarn test <files>`
+   - `aos-integration` → `yarn test <files>`
+   - `device` → `cd $HB_DIR && rebar3 eunit --module=<module>`
+   - `device-integration` → `yarn test <files>`
+   - `frontend-test` → `cd frontend && npm run test:unit`
+   - `frontend-integration` → `cd frontend && npm run test:e2e`
+   - `validate` → run all validation gates
+
+   If any test task fails, set that task back to `"in_progress"` in tasks.json and resume debugging it. Do NOT skip over failing tests just because the task was previously marked done.
 
 If no plan exists, proceed to step 2.
 
@@ -75,7 +88,7 @@ Before starting the build loop, check which tracks are selected and verify their
 grep '^CWD=' .env.hyperbeam 2>/dev/null | cut -d= -f2-
 ```
 
-If the plan includes `device`, `device-test`, `device-integration`, `aos-integration`, `module-lua`, `module-wasm`, or `module-test` tasks, verify:
+If the plan includes `device`, `device-integration`, `aos-integration`, `module-lua`, `module-wasm`, or `module-test` tasks, verify:
 
 1. `.env.hyperbeam` exists and has a `CWD` value
 2. The `CWD` path points to a valid HyperBEAM directory (`$CWD/src` exists)
@@ -108,8 +121,7 @@ b. Read the skill file for this task's type and follow its instructions. The map
 | `module-lua` | `.claude/skills/build-module/SKILL.md` |
 | `module-wasm` | `.claude/skills/build-module/SKILL.md` |
 | `module-test` | `.claude/skills/build-module/SKILL.md` |
-| `device` | `.claude/skills/build-device/SKILL.md` |
-| `device-test` | `.claude/skills/build-device/SKILL.md` |
+| `device` | `.claude/skills/build-device/SKILL.md` (eunit tests are inline — same file) |
 | `device-integration` | `.claude/skills/test-device/SKILL.md` |
 | `frontend` | `.claude/skills/build-frontend/SKILL.md` |
 | `frontend-test` | `.claude/skills/build-frontend/SKILL.md` |
@@ -125,12 +137,21 @@ d. After completing, verify the task's `done_when` criteria are met:
 
 e. If the criteria are met, update the task status to `"done"` in `tasks.json`.
 
-f. If a step fails, retry up to 3 times. On each retry:
-   - Read the error output
-   - Fix the code
-   - Re-run
-
-g. If still failing after 3 attempts, **stop and ask the user**: retry, skip, or debug manually?
+f. **If tests fail, keep debugging.** Do not stop. On each iteration:
+   1. Read the full error output — stack traces, assertion messages, log lines
+   2. Identify the root cause (wrong logic, missing handler, bad import, timing issue, etc.)
+   3. Fix the code — not the test, unless the test itself has a bug
+   4. Re-run the failing test file specifically (faster feedback than full suite)
+   5. If the same error persists after 3 different fix attempts, step back:
+      - Re-read the relevant docs (AOS patterns, HyperBEAM device protocol, etc.)
+      - Check if the plan itself has a wrong assumption
+      - Try a completely different approach
+   6. Continue iterating until all tests pass — there is no retry limit
+
+g. Only escalate to the user if:
+   - The failure is environmental (port conflict, missing binary, permissions)
+   - The test requires user input (wallet, external service URL)
+   - You've tried 10+ iterations with no progress on the same error
 
 h. Move to the next task.
 
@@ -161,7 +182,8 @@ Overall: PASS / FAIL
 
 ## Failure handling
 
-- If a skill exits with test failures, read the output, fix the code, and re-run.
+- **Test failures are expected.** The build loop is: write code → run tests → read failures → fix → re-run. This is the core loop — never skip it, never give up early.
+- If a skill exits with test failures, read the full output, diagnose the root cause, fix the code (not the test), and re-run. Keep iterating until 100% pass.
 - If a skill cannot be dispatched (unknown type), skip and warn.
 - If the user interrupts, save current state to tasks.json so the next session can resume.
 
@@ -180,7 +202,7 @@ Never force a task to `done` status with failing tests. The TaskCompleted hook w
 
 ### Build stalls on a single task
 - Check if it's a test failure loop — read the last test output
-- If the same error repeats 3 times, the issue may be in the plan, not the code
+- If the same error persists after 3 different fix attempts, step back and reconsider — the plan may have a wrong assumption
 - Run `/debug` to diagnose port/process/WASM issues
 
 ### Resume doesn't pick up the right task

package/cjs/workspace/.claude/skills/build-aos/SKILL.md

@@ -117,4 +117,13 @@ For each test-fix cycle:
 3. Classify: is the bug in source code or test code?
 4. Fix ONE issue per iteration (don't change multiple things at once)
 5. Re-run only the failing test first, then full suite
-6. If the same test fails 3 times with the same error, stop and reconsider the approach — the plan may need updating
+6. If the same error persists after 3 different fix attempts, step back:
+   - Re-read the relevant docs (AOS patterns, Lua conventions, etc.)
+   - Check if the plan itself has a wrong assumption
+   - Try a completely different approach
+7. Continue iterating until all tests pass — there is no retry limit
+
+Only escalate to the user if:
+- The failure is environmental (missing binary, permissions, port conflict)
+- The test requires user input (wallet, external service URL)
+- You've tried 10+ iterations with no progress on the same error

package/cjs/workspace/.claude/skills/build-device/SKILL.md

@@ -59,7 +59,7 @@ Do NOT mark the task as done if any prerequisite fails. Set the task status to `
 
 3. Read `docs/hyperbeam-dev.md` for the device protocol (arity/3 functions, state management, auth patterns).
 
-4. **If the task type is `device`** — write the Erlang device:
+4. Write the Erlang device with **inline eunit tests** (HyperBEAM convention — device and tests live in the same file):
 
    Write `$HB_DIR/src/dev_{name}.erl`:
 
@@ -67,6 +67,9 @@ Do NOT mark the task as done if any prerequisite fails. Set the task status to `
    -module(dev_{name}).
    -export([info/3, init/3, compute/3]).
    -include("include/hb.hrl").
+   -ifdef(TEST).
+   -include_lib("eunit/include/eunit.hrl").
+   -endif.
 
    %% Exports: list available keys
    info(_Msg1, _Msg2, Opts) ->
@@ -88,35 +91,37 @@ Do NOT mark the task as done if any prerequisite fails. Set the task status to `
        {ok, Msg1};
    handle_action(_, Msg1, _Msg2, _Opts) ->
        {ok, hb_maps:put(<<"Error">>, <<"Unknown action">>, Msg1)}.
-   ```
-
-   Key patterns:
-   - Use `hb_maps` for state (not plain maps)
-   - Use `hb_private` for secrets
-   - Use `ar_wallet` for auth/signing
-   - Route actions via `hb_ao:get(<<"Action">>, Msg2, Opts)`
-   - Return `{ok, UpdatedMsg}` or `{error, Reason}`
-
-5. **If the task type is `device-test`** — write eunit tests:
-
-   Write `$HB_DIR/test/dev_{name}_tests.erl`:
 
-   ```erlang
-   -module(dev_{name}_tests).
-   -include_lib("eunit/include/eunit.hrl").
+   %%%===================================================================
+   %%% EUnit Tests (inline — HyperBEAM convention)
+   %%%===================================================================
+   -ifdef(TEST).
 
    info_test() ->
-       {ok, Info} = dev_{name}:info(#{}, #{}, #{}),
+       {ok, Info} = info(#{}, #{}, #{}),
        ?assertMatch(#{<<"exports">> := _}, Info).
 
    compute_test() ->
-       {ok, State} = dev_{name}:init(#{}, #{}, #{}),
+       {ok, State} = init(#{}, #{}, #{}),
        Msg = #{<<"Action">> => <<"MyAction">>},
-       {ok, Result} = dev_{name}:compute(State, Msg, #{}),
+       {ok, Result} = compute(State, Msg, #{}),
        ?assertMatch(#{}, Result).
+
+   -endif.
    ```
 
-6. Compile (use the `$HB_DIR` path):
+   Key patterns:
+   - **Device + tests in same file** — use `-ifdef(TEST).` / `-endif.` guards
+   - Tests call local functions directly (no `module:function` prefix needed)
+   - Use `hb_maps` for state (not plain maps)
+   - Use `hb_private` for secrets
+   - Use `ar_wallet` for auth/signing
+   - Route actions via `hb_ao:get(<<"Action">>, Msg2, Opts)`
+   - Return `{ok, UpdatedMsg}` or `{error, Reason}`
+
+   **Do NOT create separate test files** in `$HB_DIR/test/`. All eunit tests go inline in the device source file.
+
+5. Compile (use the `$HB_DIR` path):
 
    ```bash
    cd $HB_DIR && rebar3 as genesis_wasm compile
@@ -130,10 +135,10 @@ Do NOT mark the task as done if any prerequisite fails. Set the task status to `
 
    If the beam file is missing, compilation failed silently. Read the full output and fix.
 
-7. Run eunit tests:
+6. Run eunit tests (note: test the device module directly, not a separate test module):
 
    ```bash
-   cd $HB_DIR && rebar3 eunit --module=dev_{name}_tests
+   cd $HB_DIR && rebar3 eunit --module=dev_{name}
    ```
 
 8. If compilation errors or test failures:
@@ -175,4 +180,13 @@ For each test-fix cycle:
 3. Classify: is the bug in source code or test code?
 4. Fix ONE issue per iteration (don't change multiple things at once)
 5. Re-run only the failing test first, then full suite
-6. If the same test fails 3 times with the same error, stop and reconsider the approach — the plan may need updating
+6. If the same error persists after 3 different fix attempts, step back:
+   - Re-read the relevant docs (HyperBEAM device protocol, Erlang patterns, etc.)
+   - Check if the plan itself has a wrong assumption
+   - Try a completely different approach
+7. Continue iterating until all tests pass — there is no retry limit
+
+Only escalate to the user if:
+- The failure is environmental (rebar3 missing, Erlang version, port conflict)
+- The test requires user input (wallet, external service URL)
+- You've tried 10+ iterations with no progress on the same error

package/cjs/workspace/.claude/skills/build-frontend/SKILL.md

@@ -112,20 +112,23 @@ cd frontend && npx playwright --version 2>/dev/null || echo "Playwright not inst
    cd frontend && npm run test:unit
    ```
 
-7. If any tests fail:
-   - Read the error output
-   - Fix the component or test code
-   - Re-run tests
-   - Repeat until **100% pass**
+7. **If tests fail, keep debugging.** Do not stop. On each iteration:
+   1. Read the full error output — stack traces, assertion messages, log lines
+   2. Identify the FIRST failing test (fix failures in order)
+   3. Classify: is the bug in component code or test code?
+   4. Fix ONE issue per iteration (don't change multiple things at once)
+   5. Re-run the failing test file specifically (faster feedback than full suite)
+   6. If the same error persists after 3 different fix attempts, step back:
+      - Re-read the relevant docs (`wao/web` patterns, React testing library, vitest mocking)
+      - Check if the plan itself has a wrong assumption
+      - Try a completely different approach
+   7. Continue iterating until all tests pass — there is no retry limit
+
+   Only escalate to the user if:
+   - The failure is environmental (missing dependency, port conflict, permissions)
+   - The test requires user input (wallet, external service URL)
+   - You've tried 10+ iterations with no progress on the same error
 
 8. Update the task status to `"done"` in `tasks.json`.
 
-## Iteration Protocol
-
-For each test-fix cycle:
-1. Run tests and capture FULL output
-2. Identify the FIRST failing test (fix failures in order)
-3. Classify: is the bug in source code or test code?
-4. Fix ONE issue per iteration (don't change multiple things at once)
-5. Re-run only the failing test first, then full suite
-6. If the same test fails 3 times with the same error, stop and reconsider the approach — the plan may need updating
+    **IMPORTANT**: Only mark done if all tests pass 100%.

package/cjs/workspace/.claude/skills/build-module/SKILL.md

@@ -244,7 +244,16 @@ For each test-fix cycle:
 3. Classify: is the bug in module code or test code?
 4. Fix ONE issue per iteration (don't change multiple things at once)
 5. Re-run only the failing test first, then full suite
-6. If the same test fails 3 times with the same error, stop and reconsider the approach — the plan may need updating
+6. If the same error persists after 3 different fix attempts, step back:
+   - Re-read the relevant docs (custom module patterns, WASM64/Lua conventions, etc.)
+   - Check if the plan itself has a wrong assumption
+   - Try a completely different approach
+7. Continue iterating until all tests pass — there is no retry limit
+
+Only escalate to the user if:
+- The failure is environmental (cargo missing, WASM build tools, port conflict)
+- The test requires user input (wallet, external service URL)
+- You've tried 10+ iterations with no progress on the same error
 
 ## Troubleshooting
 

package/cjs/workspace/.claude/skills/plan/SKILL.md

@@ -119,8 +119,7 @@ Plan a feature before building it. The plan and tasks are written to files so an
 | `module-lua` | `/build-module` |
 | `module-wasm` | `/build-module` |
 | `module-test` | `/build-module` |
-| `device` | `/build-device` |
-| `device-test` | `/build-device` |
+| `device` | `/build-device` (eunit tests inline — same file) |
 | `device-integration` | `/test-device` |
 | `frontend` | `/build-frontend` |
 | `frontend-test` | `/build-frontend` |
@@ -134,8 +133,8 @@ Plan a feature before building it. The plan and tasks are written to files so an
 - Tests: `{ "type": "module-test", "skill": "/build-module", "files": ["test/{name}-module.test.js"], "done_when": "yarn test test/{name}-module.test.js — all pass" }`
 
 **Device tasks** (if building Erlang devices) — add `"device"` to `tracks` array and add these to `tasks`:
-- `{ "type": "device", "skill": "/build-device", "files": ["HyperBEAM/src/dev_{name}.erl"], "done_when": "rebar3 as genesis_wasm compile — no errors" }`
-- `{ "type": "device-test", "skill": "/build-device", "files": ["HyperBEAM/test/dev_{name}_tests.erl"], "done_when": "rebar3 eunit — all pass" }`
+- `{ "type": "device", "skill": "/build-device", "files": ["HyperBEAM/src/dev_{name}.erl"], "done_when": "rebar3 compile + eunit — all pass" }`
+  - **HyperBEAM convention**: device source and eunit tests live in the same `.erl` file using `-ifdef(TEST).` guards. Do NOT create separate test files in `HyperBEAM/test/`.
 - `{ "type": "device-integration", "skill": "/test-device", "files": ["test/{name}-device.test.js"], "done_when": "yarn test test/{name}-device.test.js — all pass" }`
 
 **Frontend tasks** (if building frontend) — add `"frontend"` to `tracks` array and add these to `tasks`:
@@ -149,6 +148,15 @@ Plan a feature before building it. The plan and tasks are written to files so an
 **Final validation** — always the last task:
 - `{ "type": "validate", "skill": "/validate", "done_when": "overall PASS" }`
 
+### IMPORTANT: Replace all placeholders with actual names
+
+The templates above use `{name}` as a placeholder. When writing `tasks.json`, replace ALL placeholders with the actual file names from the plan. For example:
+- `"files": ["src/{name}.lua"]` → `"files": ["src/token.lua", "src/registry.lua"]`
+- `"files": ["test/{name}.test.js"]` → `"files": ["test/token.test.js", "test/registry.test.js"]`
+- `"done_when": "yarn test test/{name}.test.js — all pass"` → `"done_when": "yarn test test/token.test.js test/registry.test.js — all pass"`
+
+The `files` array must list every actual file the task will create. The `done_when` must reference the actual test commands. Never leave `{name}` as a literal string in the output.
+
 ### Task ordering rules
 
 The build order matters. Within each component: