@almadar/std 17.0.1 → 17.0.3

package/behaviors/lolo/cli/atoms/std-orb-lint-loop-invariant-parse.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-loop-invariant-parse [
   version: "1.0.0",
   inbound: ["cli-lint-loop-invariant-parse"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-loop-invariant-parse — the `orb lint loop-invariant-parse <file>` command. It lowers the file with program/read and walks the guard and every effect of every inline trait transition: inside the lambda of any operator taking an fn, a call to json/parse or bytes/to-string whose argument references none of that lambda's parameters, nor a name bound by a let or an inner lambda inside it, re-parses the same value for every element. Each such call is a warning ORB_W_LOOP_INVARIANT_PARSE; a call is judged against its nearest enclosing lambda and reported once. Across transitions of one orbital, a json/parse of an entity field (or of a record key read from it with object/get, directly or through array/first, array/last or array/nth) whose every set writes a json/stringify result (a whole value, or the key of an appended or assigned record) is ORB_JSON_ROUNDTRIP at the parse site; one set from any other value makes the parse legitimate. Clean answers `lint loop-invariant-parse: clean` (status 200, exit 0); warnings fail the run like errors (status 500, exit 1). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-mem-handles.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-mem-handles [
   version: "1.0.0",
   inbound: ["cli-lint-mem-handles"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-mem-handles — the `orb lint mem-handles <file>` command, the typestate check of EXEC-METAL-3 over a trait's transition graph. It lowers the file with program/read and, for every inline trait that calls a mem/ operator, walks the graph (transition = edge from each `from` state to its `to` state, guards ignored, so every written path counts) carrying the set of handle facts true on some path into each state until nothing changes. HANDLE SOURCE: a handle is named only by the exact argument `@entity.<field>` (or, inside one transition, `@payload.<field>`); an argument that is anything else (a let binding, a computed value, an array element) is skipped, no finding. A handle enters a field only where a transition sets `@entity.<f>` from `@payload.arena`, `@payload.block` or `@payload.borrow` (the documented success payloads of mem/arena-new, mem/alloc and mem/borrow); any other `set @entity.<f>` rebinds f and forgets what was known of it. Order inside one effect or guard is its pre-order, mem calls before the sets nested in the same top-level effect. ORB_MEM_USE_AFTER_FREE: a mem/ call taking the handle (alloc, borrow, write, read, read-uint, length) on a path after mem/free, mem/arena-drop or mem/release of the same source. ORB_MEM_DOUBLE_FREE: a second mem/free, mem/arena-drop or mem/release of the same source on a path; dropping an arena also kills every block field the trait allocated from that arena field (the link is a mem/alloc whose success route sets that field from `@payload.block`), so a later free of such a block is a double free. ORB_MEM_ALIAS: a mem/borrow with the literal mode \"exclusive\" of a block source while a borrow of that source is live, or any borrow while an exclusive one is live; a borrow is live from the transition that sets its field from `@payload.borrow` (the borrow effect's success route; the field must be set by exactly one borrow call's route, else it is untracked) until mem/release of that field, and two borrow calls of one source inside one transition conflict at once. ORB_MEM_LEAK: a mem/arena-new whose arena is stored in an entity field (success route sets it from `@payload.arena`) and reaches a RESTING state of the trait without mem/arena-drop of that field on some path; RESTING means the trait's initial state or a state with no transition to a different state. A `stack` arena (literal kind) dies with its dispatch and is never a leak. Not tracked: handles outside the file's inline traits (composed `uses` traits are their own file's), handles passed through a payload, a let or an emit, and arenas overwritten without a drop. Clean answers `lint mem-handles: clean` (status 200, exit 0); findings are status 500, exit 1. Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-merged-fields.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-merged-fields [
   version: "1.0.0",
   inbound: ["cli-lint-merged-fields"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-merged-fields - the `orb lint merged-fields <file>` command, the port of ORB_E_MERGED_FIELD_UNREFERENCED (validate_all_merged_field_usage in entities/entity_mutation.rs). A field a rebind merged onto an entity (`mergedFrom`) that no trait of the whole program uses is reported at `orbitals[i].entity[E].fields.<field>` of the orbital that declares the entity, sorted by field name. A trait uses an entity field when it is linked to the entity and names `@entity.<field>` or sets it anywhere (guards, effects, tick guards and effects, config defaults), lists it in a `fetch` include, writes it in a `persist` data literal (a `persist batch` too), a render-ui node of a pattern whose prop declares it required binds the entity (its own entity by default), or its entity contract requires it; a trait linked to another entity uses the fields it fetch-includes or persists, every field when it fetches or persists the entity with no data to name. The pattern requirements come from LINT_PATTERNS. Reported with the Rust message and suggestion (status 500, exit 1). Clean answers `lint merged-fields: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-missing-orbital-name.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-missing-orbital-name [
   version: "1.0.0",
   inbound: ["cli-lint-missing-orbital-name"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-missing-orbital-name — the `orb lint missing-orbital-name <file>` command, the port of ORB_X_MISSING_ORBITAL_NAME (cross_orbital/mod.rs validate_cross_orbital). It lowers the file with program/read and reports every orbital whose name is empty at `orbitals[i].name` (status 500, exit 1). Clean answers `lint missing-orbital-name: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-nav-target.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-nav-target [
   version: "1.0.0",
   inbound: ["cli-lint-nav-target"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-nav-target — the `orb lint nav-target <file>` command, a `--final` rule: every configured link a finished program states as a literal path must name a page it declares. Literal navigate effect targets are not read here: std-orb-lint-navigate owns them (ORB_EFF_NAVIGATE_TARGET_UNREACHABLE). It lowers the file with program/read and reads two sources, each under the scope that owns it: the config defaults of the app, of every orbital and of every trait (a navItems entry, a link or action href, a navigatesTo; a call-site override is the trait default, so an atom's own defaults are never seen) and the render-ui payloads of every trait transition and tick (an href or navigatesTo anywhere in the payload); a `uses lazy` page's own links count too. A target is decided only when it is a string literal or a str/concat of string literals and `@config.<name>` bindings that fold through the trait, orbital and app config defaults (so a locale prefix `(str/concat @config.pathPrefix \"/x\")` resolves); any other computed path is not reported. A target that starts with / (not //), holds no binding or brace, is not the signIn route or /login, and matches no declared page route (an inline page, an `expects page` route or a `uses lazy` page; a :name segment matches any one segment; the query, the fragment and empty segments are ignored) is ORB_NAV_TARGET_UNDECLARED. It belongs to the final pass only, as the lone atom's pages are incomplete, so it answers only the whole-program scope and its findings leave the engine under the final rule nav-target-final. Findings carry the owning location (config, orbitals[i].config, orbitals[i].traits[j], lazyPages[k]) (status 500, exit 1). Clean answers `lint nav-target: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-navigate.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-navigate [
   version: "1.0.0",
   inbound: ["cli-lint-navigate"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-navigate — the `orb lint navigate <file>` command, the port of validate_navigate and validate_send_server (effect/navigate.rs). It lowers the file with program/read, builds the declared page set (every inline page with the required payload fields of its traits' INIT events, every `expects page` route and every `uses lazy` page, a declaration keeping its own payload) and walks the effects of every inline trait transition and tick, descending through do, if, when and let. A `navigate` with no path is ORB_EFF_UNKNOWN_TYPE; a literal target that is neither an http(s) URL nor starts with / or @ is ORB_P_INVALID_PATH; a target that resolves to no declared page (the host sign-in route /login and external URLs aside, and a target that is wholly a binding) is ORB_EFF_NAVIGATE_TARGET_UNREACHABLE; a target page whose INIT requires payload fields the navigate does not pass is ORB_EFF_NAVIGATE_MISSING_PAYLOAD per field. A `send-server` with no event name is ORB_EFF_UNKNOWN_TYPE. Each finding carries the Rust path, message and suggestion (status 500, exit 1). The rule asks std-orb-effect-leaves for the navigate and send-server effects (heads: navigate, send-server) and reads the path, its str/concat prefix and the payload object's keys from their flat typed nodes. Clean answers `lint navigate: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-not-found.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-not-found [
   version: "1.0.0",
   inbound: ["cli-lint-not-found"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-not-found - the `orb lint not-found <file>` command, the `[notFound]` page lint of `orb validate --final` (G-ORB-COMPILER-004, owner-approved): the program is the whole app, so one that declares route pages (a page with a path and no protocol) must declare exactly one `[notFound]` page. No `[notFound]` page is a warning at the program, two or more is an error at the second. Each finding reads its code from the rule's `codes` record (notFoundMissing, notFoundDuplicate). Clean answers `lint not-found: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-oauth.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-oauth [
   version: "1.0.0",
   inbound: ["cli-lint-oauth"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-oauth — the `orb lint oauth <file>` command, the port of effect/oauth.rs (validate_oauth_effects): the `oauth-authorize`, `oauth-connection-status` and `oauth-connection-forget` effects, found at any depth of a guard or effect of an inline trait. The client object's keys, the provider, mode and client-auth words and the endpoint keys, and the authorize keys all come from the installed operator table through std-orb-lint-host-calls. Reports ORB_OAUTH_CLIENT_INVALID (a client that is not an object, an unknown key, a tag, mode or clientAuth that is missing, not a word or not one of the table's words, a missing clientId, not exactly one of issuer or endpoints, endpoints that are not an object, an unknown endpoint, a missing authorization or token endpoint), ORB_OAUTH_PROVIDER_UNKNOWN (a provider that is not a table word) and ORB_OAUTH_OPTION_UNKNOWN (an oauth-authorize option the table does not declare, a missing redirectUri, options that are not an object), and the ORB_HOST_EFFECT_ARITY and ORB_HOST_EFFECT_OPTION_UNKNOWN of the three oauth effects. A literal issuer or endpoint URL outside the program's `egress` is ORB_HTTP_EGRESS_UNDECLARED (the origin of the URL read with the scheme's default port, the `defaultPorts` of `browser/beacon` in the operator table), and the `emit` block of oauth-authorize, oauth-connection-status and oauth-connection-forget is checked through std-orb-emit-config with the emit keys of the operator table (ORB_EFF_EMIT_KEY_INVALID, ORB_EFF_EMIT_INVALID_NAME, ORB_EFF_EMIT_UNDECLARED_EVENT). The key findings belong to std-orb-lint-keyed-call-keys. Findings carry the Rust path (the guard or effect), message and suggestion (status 500, exit 1). Clean answers `lint oauth: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-orbital-config-dead-knob.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-orbital-config-dead-knob [
   version: "1.0.0",
   inbound: ["cli-lint-orbital-config-dead-knob"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-orbital-config-dead-knob — the `orb lint orbital-config-dead-knob <file>` command, the port of ORB_O_CONFIG_DEAD_KNOB (composition/orbital_config.rs). It resolves the file with program/read and reports each declared program-level or orbital-level config knob that no trait publishes: a trait config field whose default (or any value nested in it), forwardedFrom or nestedForwardedFrom is exactly `@config.<knob>`, closed over orbital knobs whose forwardedFrom chains out to an app knob. Findings (status 500, exit 1) carry the Rust message and suggestion. Clean answers `lint orbital-config-dead-knob: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-orbital-duplicate-name.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-orbital-duplicate-name [
   version: "1.0.0",
   inbound: ["cli-lint-orbital-duplicate-name"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-orbital-duplicate-name — the `orb lint orbital-duplicate-name <file>` command, the port of ORB_O_DUPLICATE_NAME (validate_orbital_name_uniqueness). It lowers the file with program/read and reports each orbital name declared more than once, once, at the second declaration, with every index (status 500, exit 1). Clean answers `lint orbital-duplicate-name: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-page-content-owner.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-page-content-owner [
   version: "1.0.0",
   inbound: ["cli-lint-page-content-owner"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-page-content-owner - the `orb lint page-content-owner <file>` command, the port of ORB_PAGE_AMBIGUOUS_CONTENT_OWNER and ORB_PAGE_SECOND_CONTENT_BODY (circuit/closed_circuit.rs validate_page_content_ownership, phases/program/page_content_owner.rs). Per orbital with pages it builds the trait embed graphs from `@trait.<Name>` tokens (the full graph: config defaults, guards, effects, ticks; the content channel: config defaults only, minus a trait the declaring trait paints only into non-main slots), resolves each page's content owner (a content-grade main writer designated through the channel, else the sole page-declared writer, reduced by designation and containment), and reports a page whose writers none composes the others (ORB_PAGE_AMBIGUOUS_CONTENT_OWNER, rivals not embedded by a client-bound trait) and a page-declared content writer that is neither the owner, nor embedded by a client-bound trait, nor kin to the owner (ORB_PAGE_SECOND_CONTENT_BODY). A content-grade body is a string payload, an object with children, or a pattern with an entity-kind prop (LINT_PATTERNS). The main slots are the rule's knob. A page-declared trait that is no content writer but paints a control into main (a pattern node whose event or event-ref prop holds a non-empty string) while the owner is a channel and a page trait that channels the owner paints a template-category pattern into main, and that is neither the owner, embedded by a client-bound trait, nor kin to the owner, is ORB_PAGE_CONTROL_OUTSIDE_SHELL. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint page-content-owner: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-page-empty-traits.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-page-empty-traits [
   version: "1.0.0",
   inbound: ["cli-lint-page-empty-traits"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-page-empty-traits — the `orb lint page-empty-traits <file>` command, the port. It lowers the file with program/read and, for every page of a non-spec orbital, reports ORB_P_EMPTY_TRAITS (a traits list with no entries), ORB_P_MISSING_TRAITS (no traits list and no primaryEntity) and ORB_P_INVALID_VIEW_TYPE (a viewType outside list, detail, create, edit, dashboard, custom), each with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint page-empty-traits: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-page-modifiers.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-page-modifiers [
   version: "1.0.0",
   inbound: ["cli-lint-page-modifiers"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-page-modifiers — the `orb lint page-modifiers <file>` command, the port of validate_page_modifiers. It lowers the file with program/read and, for every route page (a page with a protocol is an endpoint and is skipped), reports ORB_P_INDEX_REQUIRES_PUBLIC (an `indexing: index` page lacking `access: public`, `title:` or `description:`), ORB_P_INDEX_PARAM_ROUTE (an indexed page whose route has a `:` segment) and ORB_P_AUTH_NO_SIGN_IN (an `access: authenticated` page when the app declares no `signIn:`), each with its path and suggestion (status 500, exit 1). It also reports ORB_P_TRANSLATION_DUPLICATE_LOCALE (an explicit `translationOf:` group holding more than one page in one locale, the locale being the page path's first segment when declared, else the first declared locale). Clean answers `lint page-modifiers: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-page-path-uniqueness.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-page-path-uniqueness [
   version: "1.0.0",
   inbound: ["cli-lint-page-path-uniqueness"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-page-path-uniqueness — the `orb lint page-path-uniqueness <file>` command, the port of validate_page_path_uniqueness: pages collide only within one protocol, a route by its param-shaped path, an addressed endpoint by its address (a literal path param-shaped), and an endpoint with no address collides with nothing. It lowers the file with program/read, collapses each page path to its param shape (every :name segment becomes a bare :) and reports ORB_P_DUPLICATE_PATH once per shape shared by two or more pages across all orbitals, at the first page, with the paths and locations (status 500, exit 1). Clean answers `lint page-path-uniqueness: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-page-path.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-page-path [
   version: "1.0.0",
   inbound: ["cli-lint-page-path"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-page-path — the `orb lint page-path <file>` command, the port. It lowers the file with program/read and, for every inline page of a non-spec orbital, reports a missing or non-PascalCase page name (the PascalCase check applies to an English program only), an empty path, a path that does not start with '/', and a path starting with '/api', each with the Rust path, message and suggestion (status 500, exit 1). The character-set check (letters, numbers, hyphens, underscores, colons and slashes) applies only to an English program, as in the compiler: the program's language is decided from the raw file against the installed language packs (a .orb document by its top-level keys, a .lolo source by its first token), the packs being scanned by std-orb-language's engine. Clean answers `lint page-path: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-page-unreachable.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-page-unreachable [
   version: "1.0.0",
   inbound: ["cli-lint-page-unreachable"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-page-unreachable — the `orb lint page-unreachable <file>` command, the port of the inline-page half of validate_page_reachability. It lowers the file with program/read and reports ORB_PAGE_UNREACHABLE for every route page (a page with a protocol is an endpoint and is skipped) that nothing can route a viewer to: not the boot page (the first route page in declaration order), not a parameterized page (any :name segment), not the literal path of an href or navigatesTo value (a str/concat of literals counts) in a trait config default or a render-ui payload, not the target or static str/concat prefix of a navigate effect anywhere in a trait, not the app signIn route, and not a labelled page when the program mentions @pages. Findings carry the page location orbitals[i].pages[j] (status 500, exit 1). Clean answers `lint page-unreachable: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500. A `uses lazy` page (the program's lazyPages[], each with its path and the links its own behavior carries) is reached by an href, a navigate target or a navigate prefix longer than one character; every reached lazy page adds its links to the hrefs until nothing grows, so an unreached lazy page's links reach nothing, and a parameterized lazy page is skipped. An unreached one reports at lazyPages[k]."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-parallel-pure.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-parallel-pure [
   version: "1.0.0",
   inbound: ["cli-lint-parallel-pure"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-parallel-pure — the `orb lint parallel-pure <file>` command. ORB_X_PARALLEL_LAMBDA_IMPURE: the lambda of an `array/pmap` call (argument 1) or an `array/preduce` call (argument 2), counted after the head is not provably pure, because the order a parallel combinator runs its lambda in is not defined. The lambda must be a literal `fn` form (a computed or missing lambda cannot be proved, so it is a finding), and its body must contain no call whose head is an operator the installed table marks hasSideEffects (read from std-orb-lint-input's operator shapes), none that declares a host (the table's host field), none of the exact entropy and clock operators listed in the knob nondeterministicHeads, and no read of `@now`. The effect forms (set, emit, persist, fetch and the like) are table operators with hasSideEffects, so the table covers them, a `set @entity.<f>` included. Findings are reported at the combinator call. Clean answers `lint parallel-pure: clean` (status 200, exit 0); findings are status 500, exit 1. Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-pattern-props.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-pattern-props [
   version: "1.0.0",
   inbound: ["cli-lint-pattern-props"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-pattern-props — the `orb lint pattern-props <file>` command, the port of three registry-driven checks of the render-ui pattern walk: ORB_RUI_UNKNOWN_ITEM_ACTION_PROP (item_actions.rs validate_item_actions, the unknown-prop half), ORB_X_UNRESOLVED_PATTERN_FIELD_REF (field_path.rs validate_pattern_field_ref) and ORB_X_ENTITY_PROP_CONTRACT (pattern.rs validate_entity_prop_contract). It lowers the file with program/read and walks the pattern of every render-ui effect of every inline trait transition (an array effect's pattern at [2], an object effect's at .render_ui.pattern) the way the compiler's pattern validator does: a trait value is skipped, a typed object is checked and its children walked, a mapped (array/map c (fn x node)) child is checked as its node, an operator call or conditional in a children position is flattened to the literal fragments it combines, and the arms of a conditional node are walked. An itemAction prop is valid when it is one of the base props (label, event, icon, variant, disabled, hidden, confirm, payload, navigatesTo) or an itemActions item property declared by any pattern of the installed registry (LINT_PATTERNS). A prop the registry marks kind or itemKind field-ref must name a field of the entity the node binds (the field, or its name plus Id), or the entity-prop-contract applies: every prop whose registry schema declares requiredFields and is bound at the node needs each required field provided by the bound entity, a columns or fields map, a prop slot of that name or an @entity.<field> reference inside the node. Entity definitions are the primary and auxiliary entities of every orbital, a later one replacing an earlier one of the same name and a primary name declared in two orbitals dropped, as the compiler builds them. Findings come out in the compiler's depth-first order with its path, message and suggestion (status 500, exit 1). Clean answers `lint pattern-props: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-payload-field-name.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-payload-field-name [
   version: "1.0.0",
   inbound: ["cli-lint-payload-field-name"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-payload-field-name — the `orb lint payload-field-name <file>` command, the port of ORB_X_PAYLOAD_FIELD_NAME (payload field names are valid identifiers). It lowers the file with program/read and checks the top-level payload fields of every trait emit and event (nested properties are walked at any depth with tree/fold). Status 500, exit 1. Clean answers `lint payload-field-name: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-placement.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-placement [
   version: "1.0.0",
   inbound: ["cli-lint-placement"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-placement — the `orb lint placement <file>` command, the port of validate_placement (effect/os_grants.rs): the program's `deployment` map, which places every orbital in exactly one unit. It lowers the file with program/read and, when a `deployment` is declared, reports in unit order (the map's sorted keys) ORB_PLACEMENT_UNIT_EMPTY (a unit that lists no orbital), ORB_PLACEMENT_ORBITAL_UNKNOWN (a listed name that is no orbital of the program) and ORB_PLACEMENT_ORBITAL_DUPLICATE (an orbital placed a second time, in the same unit or another), then ORB_PLACEMENT_ORBITAL_UNPLACED for each orbital that is in no unit. A program without `deployment` is not checked. Findings carry the Rust path (`deployment.<unit>` or the orbital), message and suggestion (status 500, exit 1). Clean answers `lint placement: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-program-eval.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-program-eval [
   version: "1.0.0",
   inbound: ["cli-lint-program-eval"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-program-eval — the `orb lint program-eval <file>` command, the port of validate_program_eval (effect/program_eval.rs). It lowers the file with program/read and walks the effects of every inline trait transition and tick, descending through do, if, when and let, and checks each `program/eval` call: its `emit` option may carry only success and failure (ORB_EFF_EMIT_KEY_INVALID), each value must be a string identifier (ORB_EFF_EMIT_INVALID_NAME) declared in the trait's emits (ORB_EFF_EMIT_UNDECLARED_EVENT), and a call with no non-empty `emit.failure` drops the validator's errors (ORB_EFF_PROGRAM_EVAL_FAILURE_MISSING), each with the Rust path, message and suggestion (status 500, exit 1). The rule asks std-orb-effect-leaves for the program/eval effects (heads: program/eval) and reads the emit objects' keys and values from their flat typed nodes. Clean answers `lint program-eval: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-query-index.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-query-index [
   version: "1.0.0",
   inbound: ["cli-lint-query-index"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-query-index — the `orb lint query-index <file>` command, the check of declared `@index` access paths against the fetches that use them. It lowers the file with program/read. A path naming a field the entity does not declare (id, createdAt and updatedAt always are) or a non-scalar field (array, object, file) is [ORB_INDEX_PATH_INVALID]; a path repeating an earlier one (field and field:asc are one order) is [ORB_INDEX_PATH_DUPLICATE]. A conjunctive fetch of a persistent entity whose store driver creates no index at runtime (a driver config with an orderableFields knob) and that needs a composite index (two or more equality fields, or an equality with a range or an order on another field) is [ORB_FETCH_NEEDS_COMPOSITE_INDEX] unless a path covers it. A fetch with an equality or a range that a bound driver declines (no compare leaf, or an order outside a listed orderableFields) and that no path covers is the warning [ORB_FETCH_UNINDEXED]. A path covers a fetch when its leading fields are the fetch's equality fields in any order, a range is on the next field, and its orderBy is the fetch's orderBy. Clean answers `lint query-index: clean` (status 200, exit 0); findings answer status 500 (exit 1). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-relation-targets.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-relation-targets [
   version: "1.0.0",
   inbound: ["cli-lint-relation-targets"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-relation-targets - the `orb lint relation-targets <file>` command, the port of ORB_X_UNRESOLVED_RELATION_TARGET. It lowers the file with program/read and reports every field of type relation, at any depth, of each orbital's primary entity (both codes) and auxiliary entities (both codes, as validate_all_entities gives every auxiliary entity the same per-entity validation), whose target entity is not a declared entity of the program (any orbital's primary or auxiliary entity, or an expects entity or identity), with its path and suggestion (status 500, exit 1). A relation nested in array items or object properties with no `relation` config is reported as ORB_E_INVALID_RELATION at its `.relation` path (the top-level one is entity-field-type's). Relations nested in array items or object properties are walked at any depth with tree/fold, in the Rust order (the field, its items, its properties by name). Clean answers `lint relation-targets: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-render-ui-pattern.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-render-ui-pattern [
   version: "1.0.0",
   inbound: ["cli-lint-render-ui-pattern"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-render-ui-pattern — the `orb lint render-ui-pattern <file>` command, the port of render_ui/pattern.rs validate_pattern: the walk over every render-ui pattern of every inline trait transition (an array effect's pattern at [2], an object effect's at .render_ui.pattern), with ORB_RUI_INVALID_PATTERN (unknown pattern type or name, an operator named as a pattern, a node that is not an object, string or null), ORB_RUI_MISSING_PATTERN_TYPE, ORB_RUI_INVALID_PROP (with the did-you-mean), ORB_RUI_MISSING_REQUIRED_PROP, ORB_RUI_PROP_TYPE_MISMATCH (type, enum, if-branch enum, bare string for an array prop, render-node prop given plain objects, nested enum sub-field), ORB_RUI_ELEMENT_SHAPE_MISMATCH, ORB_RUI_FORM_FIELD_INTRINSIC, ORB_RUI_CHILD_NOT_DRAWABLE, ORB_RUI_MISSING_ACTION and ORB_A11Y_UNNAMED. The children of a pattern are read as the compiler reads them: a mapped (array/map c (fn x node)) child is checked as its node, an operator call in a children or drawable-slot position is flattened to the literal fragments its value-source slots name (the operator table's valueSourceSlots, heard as LINT_OPERATOR_WALK; an operator that declares none yields nothing), a conditional is flattened to its branches, and a conditional render node validates its arms. The pattern facts come from std-orb-lint-input's LINT_PATTERNS (the installed registry) the operator names from its LINT_OPERATOR_NAMES and the slots from its LINT_OPERATOR_WALK. It walks the tree level by level and reports the findings in the compiler's depth-first order with the Rust path, message and suggestion (status 500, exit 1). Not here: the itemActions, field-path and field-ref checks (item_actions.rs, field_path.rs) and ORB_X_ENTITY_PROP_CONTRACT. Clean answers `lint render-ui-pattern: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-reserved-component-name.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-reserved-component-name [
   version: "1.0.0",
   inbound: ["cli-lint-reserved-component-name"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-reserved-component-name — the `orb lint reserved-component-name <file>` command, the port of the entity.rs validate_entity UI-component name check. It reads the installed @almadar/core component names (LINT_COMPONENTS, from its component mapping) and, after the lint input lowers the file with program/read, reports every primary or auxiliary entity of a non-spec orbital whose name is one of them at `<entity path>.name` (ORB_E_INVALID_FIELD_NAME, the code the compiler reused): the generated entity type and the component would be duplicate identifiers in compiled output (status 500, exit 1). Clean answers `lint reserved-component-name: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-retired-effect-forms.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-retired-effect-forms [
   version: "1.0.0",
   inbound: ["cli-lint-retired-effect-forms"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-retired-effect-forms — the `orb lint retired-effect-forms <file>` command: ORB_EFF_RETIRED_FORM. An effect is an array `[\"set\", ...]`; the object form keyed by an operator (`{ \"set\": ... }`, `{ \"fetch\": ... }`, `{ \"call_service\": ... }`, an object render-ui) is retired. It lowers the file with program/read and reports every object that stands as an effect of an inline trait's transition or tick effects, or of a do, if, when or let body inside them, once at its path, naming the array form to write instead (status 500, exit 1). A render-ui pattern tree is an object by design and is not an effect slot. Clean answers `lint retired-effect-forms: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-rui-binding.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-rui-binding [
   version: "1.0.0",
   inbound: ["cli-lint-rui-binding"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-rui-binding — the `orb lint rui-binding <file>` command, the port of two render_ui/binding.rs checks over every inline trait: ORB_X_RENDER_UI_EVENT_LITERAL_STALE (a render-ui pattern, found at any depth of a transition effect, whose string prop is an event-bearing one in the installed pattern registry (kind event, event-ref, event-listen or callback) and names an event the trait does not declare in its emits, listens, event list or transitions; an empty or `@`-bound value and a trait with no declared event are skipped; the same walk runs over the pattern literals a `set` writes into a node-typed entity field) and ORB_RUI_RENDERABLE_IN_GENERIC_FIELD (a `set @entity.<field>` of a field not typed node, [node] or a container of node that receives a render-ui pattern literal, resolved through one `let` binding, at any depth through let, do, if and other call arguments). ORB_RUI_BINDING_TYPE_MISMATCH is not ported: it needs the compiler's binding type resolver (operator return types, entity and payload field types, element kinds) on arbitrary expressions. Entity definitions are the primary and auxiliary entities of every orbital, a later one replacing an earlier one of the same name and a primary name declared in two orbitals dropped. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint rui-binding: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-rui-effects.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-rui-effects [
   version: "1.0.0",
   inbound: ["cli-lint-rui-effects"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-rui-effects — the `orb lint rui-effects <file>` command, the port of three render_ui/mod.rs checks over every inline trait: ORB_RUI_INVALID_SLOT (a render-ui effect whose slot is not one of the closed slot list; a slot named by a `@config.<knob>` binding is read through the trait's declared default, as the compiler sees it after inlining, and one with no declared default is not judged), ORB_EFF_MISSING_FETCH_FOR_ENTITY (a top-level render-ui whose pattern names a literal entity that no top-level fetch in the same transition, or in any transition leading into its state, fetches; an entity bound through an `@` reference is skipped) and ORB_BINDING_TRAIT_INVALID_POSITION (an `@trait.X` string in a render-ui pattern outside a `children` array and outside a prop the installed pattern registry types as `node`). Only the top-level effects of a transition are read, array and object render-ui forms alike, exactly as the compiler does. ORB_EFF_SLOT_CONFLICT is not ported: the compiler collects the slots of a transition in a set before counting them, so no count is ever above one and the code never fires. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint rui-effects: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-schema-header.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-schema-header [
   version: "1.0.0",
   inbound: ["cli-lint-schema-header"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-schema-header — the `orb lint schema-header <file>` command, the port of ORB_S_MISSING_NAME, ORB_S_NO_ORBITALS and ORB_S_EMPTY_VERSION (cross_orbital/mod.rs validate_cross_orbital). It lowers the file with program/read and reports an empty or absent schema name, a schema with no orbitals, and a version that is present but empty, each with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint schema-header: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-service-def.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-service-def [
   version: "1.0.0",
   inbound: ["cli-lint-service-def"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-service-def — the `orb lint service-def <file>` command, the port of service.rs validate_all_services: for each orbital service, a string or `ref` object that is not Alias.services.ServiceName is ORB_GEN_INVALID_REFERENCE; an inline rest, socket or mcp service reports ORB_E_MISSING_NAME for an empty name, ORB_GEN_INVALID_VALUE for a missing or non-http baseUrl, a secretEnv that is not UPPER_SNAKE_CASE, a zero timeout, a missing or non-ws socket url and a missing mcp serverPath, and ORB_GEN_MISSING_FIELD for an api-key auth without keyName, a socket with no events and an mcp service with no capabilities; a service named like an earlier inline service is ORB_GEN_DUPLICATE. A .lolo program never carries services (the lowering sets none), so the rule fires on .orb files. It lowers the file with program/read (status 500, exit 1 on findings). Clean answers `lint service-def: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-set-column.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-set-column [
   version: "1.0.0",
   inbound: ["cli-lint-set-column"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-set-column - the `orb lint set-column <file>` command, the port of ORB_SET_COLUMN_WITHOUT_ROW (entities/entity_mutation.rs). For every inline trait linked to a persistent entity (persistence unset or persistent) that never runs `persist create|upsert|update` of that entity (a `[shared]` entity also counts a sibling trait of the orbital that does, and `persist batch` list builders are followed) and binds no row with `(set @entity.id …)` anywhere, a transition is reported for each `(set @entity.<field> …)` it runs when its event carries no row (no `id` or `row` payload field, no payload field typed @entity, the entity or a list of it, no payload field stamped with the entity) unless the field is `@intrinsic`, a restate-persistor sibling persists the very payload the field is set from, or the field only scopes a read's `filter`. Reported at the transition with the Rust message and suggestion (status 500, exit 1). Clean answers `lint set-column: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-sexpr-binding.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-sexpr-binding [
   version: "1.0.0",
   inbound: ["cli-lint-sexpr-binding"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-sexpr-binding — the `orb lint sexpr-binding <file>` command, the port of the binding checks of sexpr/binding.rs validate_binding (reached from validate_trait_sexprs): SEXPR_INVALID_BINDING (an `@` with no root), SEXPR_UNKNOWN_ENTITY (a capitalized root that is no entity of the program, no `expects entity` name and no enclosing `fn` parameter or sequential `let` name; silent when the program declares no entity) and ORB_BINDING_STATE_NO_PATH (a path after @state or @now, with this pass's own message, distinct from std-orb-lint-binding-roots'). It lowers the file with program/read and walks every `@` string of the guard, effects, ensures, state holds and tick effects of every inline trait and of the `default` of every primary entity field (and its items and properties), reading `fn` and `let` scopes as the compiler does. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint sexpr-binding: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-sigil-context.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-sigil-context [
   version: "1.0.0",
   inbound: ["cli-lint-sigil-context"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-sigil-context - the `orb lint sigil-context <file>` command, the port of ORB_BINDING_UNKNOWN_ROOT and ORB_BINDING_PAYLOAD_IN_TICK (traits/sigil_context.rs). It lowers the file with program/read and walks the guard and effects of every inline trait transition (guard and effect context) the `@ensures` of every transition (guard sigils plus the `ensuresSigils` knob), the `@holds` of every state and the invariants of every entity and auxiliary entity (guard sigils), and the effects of every tick (tick context): every `@root` binding string must name a sigil the installed @almadar/core binding rules allow in that context (read from LINT_LANGUAGE_FACTS), unless it is bound by an enclosing `(fn (x) ...)` parameter, a sequential `let` name, or, inside a collection callback (a collection or std-array operator of two or more arguments in the installed operator table, read from LINT_OPERATOR_SHAPES), `item` / `index`. `@item` / `@index` outside a callback get the out-of-scope diagnostic; `@payload` in a tick is ORB_BINDING_PAYLOAD_IN_TICK; PascalCase roots (entity bindings) are skipped. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint sigil-context: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-sign-in-route.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-sign-in-route [
   version: "1.0.0",
   inbound: ["cli-lint-sign-in-route"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-sign-in-route — the `orb lint sign-in-route <file>` command, the port of validate_sign_in_route. It lowers the file with program/read and reports ORB_P_HOST_RESERVED_ROUTE for any page declared on the host's own `/login` route, and ORB_P_SIGN_IN_UNKNOWN_ROUTE when the app's `signIn:` route (other than `/login`) is no page of the program or is itself `access: authenticated` (route params compare as one `:` segment), each with its path and suggestion (status 500, exit 1). Pages recorded by `uses lazy` (the program's lazyPages) count as pages for both checks, but a lazy page's own access is not read. Clean answers `lint sign-in-route: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-slot-tick.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-slot-tick [
   version: "1.0.0",
   inbound: ["cli-lint-slot-tick"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-slot-tick — the `orb lint slot-tick <file>` command, the port of ORB_SLOT_CONTENTION_TICK (slot.rs validate_tick_slot_contention). It lowers the file with program/read (the resolved program, whose inferred effect rows carry each trait's call-site config substituted) and, for every page with two or more mounted traits (a by-ref mount resolves to the orbital's inline trait of that name, an unresolved mount is dropped), collects per trait whose ticks include one not statically false the slots its effect row paints from inside a ticks block (a literal, resolved render-ui resource at the tick site). A slot two or more mounts paint is reported once at the page (orbitals[i].pages[j]) with the participating trait names sorted (status 500, exit 1). A tick guard is statically false by the kernel's table: false, null, 0, the empty string or object or list, an `and` with a dead operand, an `or` of only dead operands, a `not` of a statically true operand, or a comparison of two differing (or, for !=, equal) literals. Clean answers `lint slot-tick: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-slot.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-slot [
   version: "1.0.0",
   inbound: ["cli-lint-slot"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-slot — the `orb lint slot <file>` command, the port of the page slot checks ORB_SLOT_MAIN_NOT_COVERED (a page passes when any trait on it paints a non-null render-ui on any slot in any transition), ORB_SLOT_CONTENTION, ORB_SLOT_CONTENTION_RUNTIME (slot.rs validate_page_slots) and ORB_SLOT_INVALID_NESTING, which by owner ruling (2026-10-24) flags real nesting only: a trait, in a state an arm entered by painting overlay A, takes a live arm that paints a different overlay B without clearing A, or one arm paints two overlays; two traits each owning one overlay never nest (slot.rs validate_slot_nesting flagged any two overlay slots on a page). It lowers the file with program/read and walks the traits of every route page (an endpoint or boot page is not checked), resolving by-ref page traits to their declarations (wider than Rust by owner ruling), leaving out a trait a sibling embeds with `@trait.X` (it paints inside that sibling, so it owns no page slot), reading a render-ui anywhere in an arm's effects (inside `if` and `do` too), counting a trait once per slot and never reporting contention on the shared overlay slots modal and toast, and reports each slot finding (a slot named by a `@config.<knob>` binding is read through the trait's declared default, as the compiler sees it after inlining) with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint slot: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-state-shape.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-state-shape [
   version: "1.0.0",
   inbound: ["cli-lint-state-shape"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-state-shape — the `orb lint state-shape <file>` command, the port of ORB_T_DUPLICATE_STATE, ORB_T_MULTIPLE_INITIAL_STATES, ORB_T_NO_INITIAL_STATE, ORB_T_MISSING_INIT_TRANSITION and ORB_T_EXTERNAL_INPUT_NOT_RESTING (trait_validator.rs validate_state_machine). A trait needs an INIT arm on its initial state only when a route page mounts it (or a route trait embeds it) and it paints a page body (main, content or screen, or a slot it cannot resolve); a helper that renders nothing, only toasts or only opens an overlay needs none. It lowers the file with program/read and, for every inline trait with a state machine, reports an empty state list (and stops there), each repeated state name, no initial state, and several initial states (listed as the Rust debug form), each with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint state-shape: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-state-unreachable.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-state-unreachable [
   version: "1.0.0",
   inbound: ["cli-lint-state-unreachable"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-state-unreachable — the `orb lint state-unreachable <file>` command, the port of ORB_T_STATE_UNREACHABLE (trait_validator.rs validate_state_machine). It lowers the file with program/read and, for every inline trait with an initial state, follows the transition edges from the first initial state (a `*` source adds no edge; the INIT self-loop on the initial state is skipped) and reports each declared state not reached, with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint state-unreachable: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-store-binding.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-store-binding [
   version: "1.0.0",
   inbound: ["cli-lint-store-binding"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-store-binding — the `orb lint store-binding <file>` command, the port of store_binding.rs (EXEC-STORE-4). It lowers the file with program/read and checks the program-level store and each entity store (primary and auxiliary): ORB_STORE_ON_NON_PERSISTENT for a store on a runtime or browser-local entity, then, once per driver at its first binding, ORB_STORE_UNKNOWN_ORBITAL for a driver naming no orbital and ORB_STORE_DRIVER_CONTRACT for a driver with no trait handling every row verb; then, when the program binds a driver, ORB_STORE_VERB_OUTSIDE_SEAM for each (emit <row verb> …) in a trait outside a driver orbital (the store seam alone asks a driver, one frame per ask); then ORB_STORE_DRIVER_NOT_CONDITIONAL for a single persist delete or update on an entity whose driver declares writeCapabilities.conditional false (status 500, exit 1). a driver declaring `queryCapabilities.indexes` runtime or deploy with no trait handling ROWS_ENSURE_INDEXES is ORB_STORE_DRIVER_CONTRACT too (a driver declaring none, or nothing, needs no such verb). Clean answers `lint store-binding: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-theme-pin-contradicts-app.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-theme-pin-contradicts-app [
   version: "1.0.0",
   inbound: ["cli-lint-theme-pin-contradicts-app"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-theme-pin-contradicts-app — the `orb lint theme-pin-contradicts-app <file>` command, the port of ORB_THEME_PIN_CONTRADICTS_APP (theme.rs validate_theme_pin_matches_app). It lowers the file with program/read and, when the app declares a theme (a key, or an inline theme's name), reports each orbital whose traits pin a literal non-empty config.theme default (not an @ binding) that differs from it, listing the distinct pins sorted (status 500, exit 1). Clean answers `lint theme-pin-contradicts-app: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-theme-ref.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-theme-ref [
   version: "1.0.0",
   inbound: ["cli-lint-theme-ref"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-theme-ref — the `orb lint theme-ref <file>` command, the port of the ORB_X_UNKNOWN_THEME check of theme.rs (validate_theme_ref). It lowers the file with program/read and checks every theme given by reference: the app `theme`, each orbital `theme` and each entry of the app `themes` list. A reference is accepted when it has the form `Alias.theme`, names an inline theme declared by an orbital, or is one of the built-in theme keys that std-orb-lint-input sends in LINT_UI_VOCAB (orbLanguage.uiVocabulary.themeKeys); an inline theme definition is not judged here. Findings carry the compiler's message at `theme`, `orbitals[<i>].theme` or `themes[<i>]` (status 500, exit 1). An unreadable vocabulary answers ORB_LINT_UI_VOCAB_UNREAD. Clean answers `lint theme-ref: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-theme-undeclared.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-theme-undeclared [
   version: "1.0.0",
   inbound: ["cli-lint-theme-undeclared"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-theme-undeclared — the `orb lint theme-undeclared <file>` command, the port of ORB_THEME_UNDECLARED (theme.rs validate_data_themes, G-UI-106). It lowers the file with program/read and, per trait, folds every transition effect, tick effect and config default for a `data-theme` value that resolves to a literal theme (the string itself, or the literal string default of the `@config.<knob>` it reads; an unset knob, another binding or an empty value is no theme). A theme whose base (the key without its -dark or -light mode) is not declared by the app theme, an orbital theme (a key or an inline theme name) or the `themes` list is reported once per trait, sorted (status 500, exit 1). Clean answers `lint theme-undeclared: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-theme-values.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-theme-values [
   version: "1.0.0",
   inbound: ["cli-lint-theme-values"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-theme-values — the `orb lint theme-values <file>` command, the port of the inline-theme findings of theme.rs validate_theme_definition: ORB_GEN_INVALID_VALUE for a token color that is not a CSS color (hex of 3, 4, 6 or 8 digits, rgb, hsl, var(, or letters and hyphens), a radius or spacing that is not a CSS length (0, var(, a number with an optional px, rem, em, %, vh, vw, pt, ch or ex unit) and a malformed font-family stack (typeScale display, body and mono families, typography font-family keys), in the app theme and each orbital theme, in the tokens and in each variant (sorted by name), and ORB_E_MISSING_NAME for an inline theme with no name. It lowers the file with program/read and reports in the order of the Rust check (status 500, exit 1). Clean answers `lint theme-values: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-tick-requires-runtime.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-tick-requires-runtime [
   version: "1.0.0",
   inbound: ["cli-lint-tick-requires-runtime"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-tick-requires-runtime — the `orb lint tick-requires-runtime <file>` command, the port of ORB_TICK_REQUIRES_RUNTIME (entity_mutation.rs validate_trait_tick_guards). It lowers the file with program/read and, for every inline trait that declares at least one non-cron tick (a numeric interval, or a string that is not a valid 5-field cron expression, as `orbital_core_base::cron::is_valid_cron_expression` decides) and is linked to a persistent entity (no persistence mode, or `persistent`; the last entity of that name in the program wins, auxiliary entities included), reports the trait once at `...ticks` with the Rust message and suggestion (status 500, exit 1). It also reports ORB_TICK_ASYNC_EFFECT for each effect of a non-cron tick whose tree calls an operator of the registry's std-llm category (llm/call-tools, llm/compact, llm/embed, llm/generate, llm/switch, llm/token-count), found with tree/fold, at `...ticks[i].effects[j]`. Clean answers `lint tick-requires-runtime: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-time-unit.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-time-unit [
   version: "1.0.0",
   inbound: ["cli-lint-time-unit"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-time-unit - the `orb lint time-unit <file>` command, the port of ORB_OP_INVALID_TIME_UNIT (types/time_unit.rs). It lowers the file with program/read and walks every inline trait transition guard, transition effect and tick effect through arrays AND objects (so a unit inside a render-ui prop is reached). A time operator whose `unit` param is a literal union in the installed operator table (std-time, read from LINT_OPERATOR_SHAPES: its position and accepted literals) and whose argument at that position is a string literal outside the union is reported at <expression path>[<position>] (status 500, exit 1); a missing optional unit or a computed unit is left to the evaluator. The message lists the accepted spellings of the installed table where the compiler prints its fixed vocabulary string. Clean answers `lint time-unit: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-trait-embeds.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-trait-embeds [
   version: "1.0.0",
   inbound: ["cli-lint-trait-embeds"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-trait-embeds - the `orb lint trait-embeds <file>` command, the port of the trait-typed and orbital-typed embed checks of traits/trait_validator.rs. For every inline trait: a `trait`-typed config field whose default is neither `none`, an `@trait.<PascalName>` string nor a trait value (an object with a behavior specifier and a PascalCase trait) is ORB_BINDING_TRAIT_INVALID_FORMAT. A `render-ui` of the trait's transitions and ticks that embeds `@config.<knob>` for a `trait`-typed knob defaulting to `none`, or `@entity.<field>` for a `trait`- or `behavior`-typed field of the linked entity, is ORB_RENDER_UNBOUND_TRAIT_KNOB_EMBEDDED unless it sits in the then-branch of an `if` or `when` whose condition is that binding (or `(validate/required <binding>)` at the effect level); an embed of `@entity.<field>` for an `orbital`-typed field is ORB_RENDER_ORBITAL_VALUE_EMBEDDED whatever the guard. Each finding carries the Rust path (the effect), message and suggestion (status 500, exit 1). Clean answers `lint trait-embeds: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-trait-id-uniqueness.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-trait-id-uniqueness [
   version: "1.0.0",
   inbound: ["cli-lint-trait-id-uniqueness"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-trait-id-uniqueness — the `orb lint trait-id-uniqueness <file>` command, the port of ORB_X_DUPLICATE_TRAIT_ID. It lowers the file with program/read, groups every inline trait that carries an id by that id across all orbitals, and reports each id carried by more than one trait, in id order, naming Orbital.Trait for every holder (status 500, exit 1). Traits without an id are not compared. Clean answers `lint trait-id-uniqueness: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-trait-mounts.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-trait-mounts [
   version: "1.0.0",
   inbound: ["cli-lint-trait-mounts"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-trait-mounts - the `orb lint trait-mounts <file>` command, the port of the mount checks of traits/trait_validator.rs (traits/mounts.rs). Per orbital it reads which traits its pages list: a route page (no protocol) lists a trait for the route, a page of another protocol lists it for an endpoint; a trait embedded (`@trait.<Name>` in a config default, a guard, an effect or a tick) by a route-listed trait is route-mounted too. A trait listed on an endpoint and on a route is ORB_T_TRAIT_ON_ROUTE_AND_ENDPOINT, and one mounted only on endpoints that renders UI (a render-ui anywhere in its transition or tick effects) is ORB_T_ENDPOINT_TRAIT_RENDERS. ORB_T_INIT_MISSING_FETCH is reported once per persistent entity read by route-mounted traits that paint a body slot (main, content, screen, an unreadable slot or a `@config` slot) and that neither create the entity nor lack an initial state, when no trait of the orbital fetches (or refs) the entity in a top-level effect of an INIT transition leaving its initial state; the path names the first such trait. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint trait-mounts: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]