Clean up rebranding drift in docs, agent configs, and source comments

Fix stale references left over from the alknet-typedef → alktype migration:
- .opencode/agents/: replace @alkdev/alknet constraints (tokio, crypto, feature
  flags, anyhow/thiserror) with alktype-accurate ones (sync, AlkTypeError,
  WASM-clean); fix @alkimiadev → @alkdev org name; remove nonexistent AGENTS.md
  ref; replace alknet-http/alknet-agent spec examples
- docs/sdd_process.md: fix wrong package name (@alkdev/storage → @alkdev/alktype)
- docs/architecture/: rewrite dangling /workspace/ and docs/research/ paths as
  @alkdev/alknet: cross-repo references with explanatory notes; fix
  @alkimiadev → @alkdev; fix 'not yet used by any alknet crate' stale context
- src/ + tests/: correct '17 AlkType kinds' → '19' in doc comments (enum has 19
  variants; pre-existing count error); fix dangling /workspace/ path in
  poc_roundtrip.rs

.opencode/agents/architect.md

@@ -326,15 +326,15 @@ result, a concrete use case to arrive.
 
 A decision should be `deferred(scope)` when:
 
-- The use case isn't concrete (e.g., "we don't know what the agent crate
-  will need from the call protocol")
+- The use case isn't concrete (e.g., "we don't know if any consumer needs
+  arrays of variable-length-element structs")
 - The options depend on something that doesn't exist yet (e.g.,
-  "depends on the alknet-http crate spec")
+  "depends on a concrete consumer schema that needs this feature")
 - The trade-off requires data that can only come from implementation
   (e.g., "need performance benchmarks to choose between X and Y")
 - The decision is genuinely not needed for the current scope (e.g., "the
-  current scope is core + call crates; this question is about the agent
-  crate")
+  current scope is the core engine; this question is about a builder API
+  that no current consumer needs")
 
 ### `deferred(unclear)` — the pieces exist but the shape isn't clear
 
@@ -373,10 +373,10 @@ A decision should be `deferred(unclear)` when:
    (implies it's decided).
 2. **State the blocking condition** (`deferred(scope)`) or
    **investigation target** (`deferred(unclear)`) — what specific thing
-   would unblock this? Be concrete: "blocked on: alknet-agent crate spec
-   exists" or "investigation: work through 2+ example outbound-dial use
-   cases (hub→worker, worker→hub) to see how verifier-selection +
-   provider + connector compose."
+   would unblock this? Be concrete: "blocked on: a concrete consumer that
+   needs arrays of variable-length-element structs" or "investigation:
+   work through 2+ example schemas with nested variable-length arrays to
+   see how the lazy walking logic would compose."
 3. **State the impacts** — what does this block downstream? Be
    specific: "blocks the first hub deployment because the hub dials
    workers" not "blocks the hub crate." This is the triage signal that

.opencode/agents/code-reviewer.md

@@ -111,13 +111,13 @@ cargo fmt --check                                              # Format check
 For this project, also verify:
 
 - No comments in code (per project convention)
-- Error handling uses `anyhow::Result` (application) / `thiserror` (library) — no
-  panics in library code
-- Feature flags are used correctly (`tls`, `iroh`, `acme`) — base crate compiles
-  lean
+- Error handling uses `AlkTypeError` (hand-rolled enum in `src/error.rs`) — no
+  panics in library code, no `anyhow`/`thiserror`
+- No feature flags (the crate has none) — only `serde_json` + `jsonschema` deps
 - Public API is well-documented with `///` doc comments where appropriate
-- Module structure follows Rust conventions (`mod.rs`, `lib.rs`)
+- Module structure follows Rust conventions (`lib.rs`)
 - No unnecessary `unwrap()` or `expect()` in library code
+- WASM-clean: no platform deps, no tokio, no async
 
 #### E. Security
 

.opencode/agents/coordinator.md

@@ -20,7 +20,7 @@ You manage the execution of decomposed task graphs:
 - Handle blocks and anomalies when they arise
 - Run an after-action review when the task graph is complete
 
-## The `worktree` Tool (via @alkimiadev/open-coordinator)
+## The `worktree` Tool (via @alkdev/open-coordinator)
 
 You use the **worktree** tool with `{action, args}` dispatch. Role is
 auto-detected — coordinator sessions get the full operation set, spawned
@@ -191,7 +191,7 @@ also include:
 Example prompt template:
 
 ```
-You are an implementation specialist for the @alkdev/alknet project.
+You are an implementation specialist for the @alkdev/alktype project.
 
 Your task: {{task}}
 
@@ -204,13 +204,14 @@ Your task: {{task}}
 7. Push: git push origin $(git branch --show-current)
 8. Notify: worktree({action: "notify", args: {message: "Task completed: {{task}}. <brief summary>", level: "info"}})
 
-Key project constraints (@alkdev/alknet):
+Key project constraints (@alkdev/alktype):
 - Rust: use cargo build, cargo clippy, cargo fmt, cargo test
 - No comments in code
-- anyhow::Result for application errors, thiserror for library error types
-- Feature flags for transports (tls, iroh, acme)
-- Async via tokio runtime
+- AlkTypeError (hand-rolled enum in src/error.rs) is the library error type
+- No async runtime (no tokio) — the engine is fully synchronous
+- No feature flags currently
 - No panics in library code
+- WASM-clean: only serde_json + jsonschema deps, no platform deps
 ```
 
 ### Partial Generation Spawning

.opencode/agents/implementation-specialist.md

@@ -207,30 +207,25 @@ This is especially important for complex tasks that span many file operations.
 
 ## Project Conventions
 
-Read `AGENTS.md` at project root for full details. Key rules:
+Key project conventions (no AGENTS.md — these are the canonical rules):
 
 1. **No comments in code** — Per project convention.
-2. **Error handling** — Use `anyhow::Result` for application code, `thiserror` for
-   library error types. Never panic in library code.
+2. **Error handling** — `AlkTypeError` (hand-rolled enum in `src/error.rs`) is
+   the library error type. No `anyhow` or `thiserror` — this is a library crate
+   with a single error enum. Never panic in library code.
 3. **No `unwrap()` or `expect()` outside tests** — These are debug signals that
    something wasn't clear. If you reach for `unwrap()`, it means the error
    handling path wasn't specified — stop and think about what should actually
    happen on that error. For poisoned locks, use
-   `unwrap_or_else(|e| e.into_inner())` or explicit error propagation. A panic
-   in one operation must not cascade to other operations.
-4. **Cryptographic nonces use `OsRng`** — AES-GCM IVs and any other cryptographic
-   nonces must use `OsRng` (or equivalent CSPRNG), never `rand::random()`. IV
-   reuse under the same key is catastrophic for GCM.
-5. **Secret material is zeroized on drop** — Any type holding derived keys,
-   decrypted credentials, or other secret material must derive `Zeroize` and
-   `ZeroizeOnDrop`. Secrets must not linger in freed heap memory.
-6. **Feature flags** — Transports are feature-gated (`tls`, `iroh`, `acme`). Base
-   crate should compile lean.
-7. **Async runtime** — `tokio` is the async runtime. All I/O is async.
-8. **Naming conventions** — Rust standard: `snake_case` for functions/variables/
+   `unwrap_or_else(|e| e.into_inner())` or explicit error propagation.
+4. **No async runtime** — The engine is fully synchronous. No tokio, no async.
+5. **No feature flags** — The crate has no feature flags currently.
+6. **WASM-clean** — Only `serde_json` + `jsonschema` dependencies. No platform
+   deps. Must compile to `wasm32-unknown-unknown`.
+7. **Naming conventions** — Rust standard: `snake_case` for functions/variables/
    modules, `PascalCase` for types/traits, `SCREAMING_SNAKE_CASE` for constants.
-9. **Module structure** — One module per component under `src/`. Re-export via
-   `mod.rs` or `lib.rs` as appropriate.
+8. **Module structure** — One module per component under `src/`. Re-export via
+   `lib.rs`.
 
 ## Key Principles