docs: feature requests from tinygrad-rsmc refactor

- module-value-access: qualified module.Variant/CONST value access or glob
  imports (cross-module enum/const usage; blocks module de-prefixing).
- freshness-direct-call-return: propagate freshness through `return fresh_call()`
  (the lone remaining RS0602 in the port).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

docs/requests/freshness-direct-call-return.md

@@ -0,0 +1,61 @@
+# Feature request: freshness propagation through a direct `return fresh_call()`
+
+**Status:** requested · **Driver:** tinygrad-rsmc clean `rss check`
+**Repro built on:** current `rss` (post literal/enum/clean-local freshness fixes)
+
+## Summary
+
+Treat `return <call-to-fresh-fn>(...)` as fresh when the callee is a known
+fresh-returning function — the same way the just-landed "clean local" rule treats
+`let s = <fresh-call>(); return s`. This is the lone remaining freshness gap.
+
+## Motivation / impact
+
+After the literal-return, enum-variant, and clean-local-propagation fixes,
+`rss check tinygrad-rss` went from **483 → 1** `RS0602` warning. The single
+remaining one is a function that simply forwards another fresh function's result
+directly in a `return`, without binding it to a local first. Closing this gets the
+port to a **0-warning** check.
+
+## Current behavior (verified)
+
+The remaining warning in the port:
+
+```
+warning[RS0602]: freshness of return value in `tensor_max_pool2d_resolved`
+  --> tinygrad-rss/src/tensor.rss:4867
+     return tensor_max_pool2d(cache: mut cache, x: x, kh: kh, ... )
+```
+
+Minimal form:
+
+```rss
+fn make() -> fresh String { return "x" }
+
+fn via_local() -> fresh String {
+    let s = make()
+    return s            // OK now (clean-local rule)
+}
+
+fn direct() -> fresh String {
+    return make()       // warning[RS0602]: freshness unknown
+}
+```
+
+The via-local spelling is already accepted; the equivalent direct spelling is not.
+
+## Proposed behavior
+
+In the freshness check, a `return E` where `E` is a call to a function whose
+return is known-fresh (declared/inferred `fresh`) is itself fresh — identical to
+binding `E` to a clean local and returning that local.
+
+## Acceptance criteria
+
+- `fn direct() -> fresh String { return make() }` checks clean.
+- `rss check tinygrad-rss` reports **0 warnings** (currently 1).
+
+## Notes
+
+- Low priority / small: it's a single warning, no behavioral effect, and a natural
+  extension of the clean-local propagation rule already implemented.

docs/requests/module-value-access.md

@@ -0,0 +1,79 @@
+# Feature request: cross-module enum-variant / constant usage
+
+**Status:** requested · **Driver:** tinygrad-rsmc module de-prefixing
+**Repro built on:** current `rss` (post module-isolation + use-aliasing)
+
+## Summary
+
+Make enum/sum **variants** and **constants** defined in one `module` usable from
+another without one `use` line per symbol. Today only per-symbol
+`use module.NAME` + bare reference works; **qualified value access fails** and
+**glob imports are unsupported**. This blocks de-prefixing enum/const-heavy files.
+
+## Motivation / impact
+
+The tinygrad-rsmc port has a single `Ops` sum type with ~100 variants
+(`ADD`, `MUL`, `GLOBAL`, `INDEX`, …) referenced across ~100 files, plus shared
+constants. To put `Ops` in `module ops`, every consumer must currently add a
+separate `use ops.ADD`, `use ops.MUL`, … — thousands of `use` lines — and two
+modules that both define a same-named variant can't be used in one file at all
+(no qualification, no aliasing for values). That makes module de-prefixing of
+these files impractical, which is the last refactor still gated.
+
+## Current behavior (verified)
+
+```rss
+// ops.rss
+module ops
+sum Ops { ADD, MUL, OTHER }
+const MAX_OPS: Int = 64
+```
+
+```rss
+// user.rss
+module user
+use ops.Ops
+use ops.ADD
+use ops.MAX_OPS
+
+fn a(o: read Ops) -> Int { return 1 }       // OK  (type via use)
+fn b() -> fresh Ops { return ADD }          // OK  (variant via use + bare)
+fn d() -> Int { return MAX_OPS }            // OK  (const via use + bare)
+
+fn c() -> fresh Ops { return ops.MUL }      // error[RS0026]: unknown value binding `ops`
+fn e() -> Int { return ops.MAX_OPS }        // error[RS0026]: unknown value binding `ops`
+```
+
+```rss
+use ops.*                                    // error[RS0015]: unsupported RSScript syntax
+```
+
+So: qualified *calls* (`ops.fn()`) resolve, but qualified *values*
+(`ops.MUL`, `ops.MAX_OPS`) do not, and there is no glob form.
+
+## Proposed behavior — either option unblocks this
+
+1. **Qualified value access:** resolve `module.Variant` and `module.CONST` in
+   value position the same way `module.fn()` already resolves in call position.
+   (Preferred — also gives per-use disambiguation for same-named variants across
+   modules, which `use` alone cannot.)
+2. **Glob import:** support `use module.*` to bring every public symbol of a
+   module into scope at once. (Simpler for the common "import the whole ops
+   enum" case; does not solve cross-module name collisions.)
+
+Ideally both; #1 is the more general fix.
+
+## Acceptance criteria
+
+- `fn c() -> fresh Ops { return ops.MUL }` and `fn e() -> Int { return ops.MAX_OPS }`
+  check clean.
+- (If #2) `use ops.*` brings `Ops`, its variants, and `MAX_OPS` into scope.
+- A file can reference two same-named variants from different modules — at least
+  one via qualification (#1).
+
+## Notes
+
+- Pairs with the portman rss-adapter `module` awareness already shipped, which
+  reconstructs the flat owner-qualified identity for de-prefixed functions.
+- Scope is enum variants and constants specifically; types and functions already
+  work via `use` / qualified calls.