@almadar/std 17.0.0 → 17.0.2

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

@@ -3,7 +3,7 @@ app std-orb-behaviors [
   inbound: ["cli-behaviors-catalog", "cli-behaviors-describe", "cli-behaviors-source", "cli-behaviors-which", "cli-behaviors-texts", "cli-behaviors-expects"],
   fs: { "/dev/fd/0": [read], cwd: "**": [read], "~/.almadar/vectors/**": [read, write, remove, create], "~/.almadar/sidecars/**": [read], "/**": [read], "~/.orb/node_modules/**": [read], env ALMADAR_VECTORS_DIR: "**": [read, write, remove, create] },
   env: ["PATH", "ALMADAR_VECTORS_DIR", "HOME", "EMBEDDING_PROVIDER", "EMBEDDING_API_KEY", "OPENAI_API_KEY", "OPEN_ROUTER_API_KEY", "EMBEDDING_MODEL", "LMSTUDIO_EMBEDDING_MODEL"],
-  exec: ["kill", "orb"],
+  exec: [exe, "kill", "orb"],
   net: { "openrouter.ai:443": [tcp], "api.openai.com:443": [tcp], "127.0.0.1:1234": [tcp] },
   description: "std-orb-behaviors — the `orb behaviors catalog|describe|source|which|texts|expects` commands over the behavior reflection operators. `catalog <scope…> [--exposure <e>]… [--json] [--no-vectors] [--no-traits] [--topics]` (`--topics` lists each package and topic once with its count, counted here over the rows) lists the installed behaviors under the scopes (`behavior/catalog`, which lists no vectors; `--no-vectors` reads no vector store) as one table row each, or as JSON with --json; `describe <behavior>.traits.<Trait>|<behavior>|<behavior>.orbitals.<Orbital>|- [--json] [--knob-vectors]` prints the description as JSON (`behavior/describe`; `-` reads a trait or orbital value as JSON from stdin; `--knob-vectors` attaches each knob's embedding vector; a whole-behavior description carries each orbital's `forwards`, the unhandled controls its `emitsScope external` traits leave for the embedder, from the control-unhandled analysis over std-orb-fired-events); `source <behavior> [--json]` prints the behavior's program as JSON (`behavior/source`); `which <spec>` prints `<path> (<owner>)`, the file the specifier resolves to and the package that owns it (`behavior/resolve` with `path: true`); `texts <scope…> [--kind organism|capability|knob] [--json]` prints the embedding texts under the scopes as one compact JSON array of { key, text, hash } (built by std-behavior-texts; `--json` is accepted, the only format). `expects <file.orb|spec> [--json]` prints each orbital's derived expectations as one compact JSON line, `{ <orbital>: { expectations, diagnostics } }` (`behavior/resolve` with `expects: true`; a spec naming an existing file under the working directory is read as that file, an absolute path when relative to the hook's cwd, `--json` is accepted, the only format). Each answers status 200 (exit 0). With vectors, the catalog lists rows asked for with `texts: true`, builds the organism and capability texts (std-behavior-texts), reads the packages' snapshots and the environment (std-vector-sources) and resolves every text's vector (std-vector-resolve: snapshots, then the user store, then the configured provider); `describe --knob-vectors` does the same for the trait's knob texts, and `texts` builds every kind itself, package by package in first-mention order and path order. A missing operand answers the usage (status 400, exit 2); a failed reflection answers its error (status 500, exit 1)."
 ]

package/behaviors/lolo/cli/atoms/std-orb-compile.lolo

@@ -2,7 +2,7 @@ app std-orb-compile [
   version: "1.0.0",
   inbound: ["cli-compile"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-compile — the `orb compile <FILE> [flags]` command (spec/cli/orb-compile.lolo; port of orbital-cli commands/compile.rs). The source is first checked by the std validate program (std-orb-validate composed here: the core checks plus the policy lints) as `--json`; any error finding refuses with status 500 on stderr `Error: <path> fails `orb validate` with N error(s), so it is not compiled:` and one `[CODE] path: message[ 💡 suggestion]` line per error. --web-client (with --mode client) lays the typescript shell's prebuilt web client, with the app's runtime files over it, in <output>/web-client, as `orb serve` prepares a client: the build path for an app that declares its own http endpoint. --skip-lint skips the std validate program (its policy lints) and generates at once; the host still runs the core checks on the source and on every .orb it writes, and refuses a program that fails them. A clean source is generated by program/eval null { generate: { path, output, shell, mode?, frontend?, backend?, backendUrl?, renderer?, patterns?, devLogs?, host?, emitOrb?, webClient? } } on the host (every relative path joined to the directory the command runs in; output defaults to ./output, shell to typescript), which validates the lowered program again, writes the project and answers { lines, files, warnings, nextSteps }: lines are exactly what `orb compile` printed, joined by newlines on stdout. A host refusal answers status 500 on stderr `Error: <reason>` (the reason carrying the `program/eval:` prefix); no file, a second file, an unknown flag or a valueless value flag answers the usage (status 400, exit 2). Known differences: a shell, mode or host value outside the accepted set is refused by the host (status 500) where clap exits 2; the header lines printed before a failure are not printed."
 ]

package/behaviors/lolo/cli/atoms/std-orb-i18n.lolo

@@ -1,7 +1,7 @@
 app std-orb-i18n [
   version: "1.0.0",
   inbound: ["cli-i18n"],
-  exec: ["orb"],
+  exec: [exe],
   env: ["PATH"],
   fs: { cwd: "node_modules/**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-i18n — the `orb i18n vocab [--json]` and `orb i18n check` commands (spec/cli/orb-i18n.lolo; golden: orbital-cli i18n.rs). The English side is installed data: the 12 parser sections are the lists in the file @almadar/core declares as orbLanguage.vocabulary, the `orb` section is read from the knob orbSource under @almadar/core (the stand-in src/i18n/en.json until core emits it into the vocabulary file), and the operator table is the key set of the file @almadar/std declares as orbLanguage.operators. The language packs come from std-orb-language (composed: its pack scan answers each pack's vocabulary text). vocab prints the 14 sections (text or 2-space JSON). check reports Missing, Empty and Orphan keys per language and section, Collision values, SelectorNotUnique first-token keywords and the parser-word coverage; clean answers `orb i18n check: ok — 0 problems`, otherwise status 500 with every problem listed, never truncated. Not ported: the parser-vs-English equality gate (the parser lists ARE the English table now)."

package/behaviors/lolo/cli/atoms/std-orb-language.lolo

@@ -2,7 +2,7 @@ app std-orb-language [
   version: "1.0.0",
   inbound: ["cli-language"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-language — two traits: OrbLanguage (the cli-language hook and its arguments) and OrbLanguageEngine (the scan, which std-orb-i18n composes alone: LANG_SCAN { cwd } answers SCAN_ANSWERED, LANGUAGE_ROW per core/std row, LANGUAGE_PACK_VOCAB per checked pack, LANGUAGE_PACKS_DONE { problem }). the `orb language which` command (spec/cli/orb-language.lolo; golden: orbital-cli language.rs run_which). The language range this orb reads is what `orb --version` answers, as `orb X.Y.Z (language R)`; any other form is refused. @almadar/core is checked by its orbLanguage.version against that range, every other language package by its orbLanguage.language range against the installed core's orbLanguage.version. One row per language package (@almadar/core, @almadar/std) resolved node-style: the working directory's node_modules, each parent's, then ~/.orb/node_modules, nearest first: `<package>@<version> → <canonical root>`, or `<package> → <CODE>: <problem>` when it is not installed, its package.json lacks the orbLanguage block or its version (core) or language range (std), the range is not a single-comparator semver range, or the language does not satisfy the range (std-semver; ORB_LANGUAGE_DATA_INCOMPATIBLE). Then one row per installed language pack (package.json declares orbVocabulary), sorted by name: `<pack>@<version> → <canonical root>`; a pack with no language or vocabulary field, a language range the installed core's language misses, an unreadable or unparseable vocabulary file, a language code claimed twice or the code en makes ONE `language packs → <CODE>: <problem>` row instead of the pack rows. Any other argument answers the usage. Not ported: the pack-vs-English coverage rules of validate_packs (the English table is not an installed file, G-STD-098) and the exact serde and OS error texts."
 ]
@@ -154,7 +154,7 @@ orbital OrbLanguageOrbital {
     state versioning {
       INIT -> versioning
       LANG_PATH_READ -> versioning
-        (os/spawn "orb" ["--version"] { cwd: null env: { PATH: (default @payload.value "") } stdin: "null" stdout: "pipe" stderr: "null" detached: false } { key: "spawn" emit: { success: LANG_SPAWNED, failure: LANG_START_FAILED } })
+        (os/spawn { anchor: "exe" } ["--version"] { cwd: null env: { PATH: (default @payload.value "") } stdin: "null" stdout: "pipe" stderr: "null" detached: false } { key: "spawn" emit: { success: LANG_SPAWNED, failure: LANG_START_FAILED } })
       LANG_START_FAILED -> idle
         (emit SCAN_ANSWERED { status: 500, body: "", stderr: (str/concat "orb language: " @payload.error) })
       LANG_SPAWNED -> versioning

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

@@ -2,7 +2,7 @@ app std-orb-lint-all [
   version: "1.0.0",
   inbound: ["cli-lint-all"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-all — the `orb lint all <file> [--json]` hook, the only declarer of cli-lint-all. It holds no rule logic: it composes the std-orb-lint-engine orbital (every file-taking std-orb-lint-* rule trait, collected into one answer), asks it LINT_RUN { file } and hears LINT_COLLECTED { findings, found }. Each rule answers its findings as { code, path, message, suggestion, severity } records, which the engine collects as they are (ORB_AUTH_GUARD_CLIENT_ONLY, ORB_O_EXTEND_FIELD_UNREAD, ORB_LISTEN_WILDCARD_UNKEYED, ORB_OS_GRANT_UNUSED and ORB_EMIT_REPEATS_IDENTICALLY are the warnings). It prints the rules with findings grouped and a total, or with --json a { findings } object of the structured findings, and exits 1 when any error-severity finding exists."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-asset-inline-url.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-asset-inline-url [
   version: "1.0.0",
   inbound: ["cli-lint-asset-inline-url"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-asset-inline-url — the `orb lint asset-inline-url <file>` command, the prevention rung of G-BEHAVIORS-101. It lowers the file with program/read and, for every orbital that composes std-asset-pack (a trait whose ref names an alias that the orbital's uses binds to std/behaviors/std-asset-pack, or any trait declaring the pack's assetPack config knob), reports each literal http:// or https:// string in the config defaults of its other traits and in its entity seed rows (instances), walked at any depth with tree/fold. The trait composed from the atom is skipped, the origin knob of a trait that declares assetPack is exempt, and the app egress entries are never read. One finding per url with its path (status 500, exit 1). Clean answers `lint asset-inline-url: 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-async-result-deaf-target.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-async-result-deaf-target [
   version: "1.0.0",
   inbound: ["cli-lint-async-result-deaf-target"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-async-result-deaf-target — the `orb lint async-result-deaf-target <file>` command, the port of ORB_CIRCUIT_ASYNC_RESULT_DEAF_TARGET (circuit/async_results.rs, run per trait from closed_circuit, not client-bound gated). It needs the RESOLVED program (program/read resolve), so a `use`-imported atom's traits are checked too. For every state-changing transition (a self-transition, or one whose multi-`from` includes the target, is skipped) it collects the event names under the `emit` option of its own `fetch`/`persist` effects (through nested arrays, not through objects; call-service is not collected) and, when the target state has no arm (a transition from that state or from `*`) for some of them, reports the sorted missing ones at `orbitals[i (O)].traits[j (T)].stateMachine.transitions[n].effects` with the Rust message and suggestion (status 500, exit 1). Clean answers `lint async-result-deaf-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-binding-fields.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-binding-fields [
   version: "1.0.0",
   inbound: ["cli-lint-binding-fields"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-binding-fields - the `orb lint binding-fields <file>` command, the port of ORB_BINDING_PAYLOAD_FIELD_UNDECLARED (direct @payload.<path> reads) and ORB_BINDING_ENTITY_FIELD_NOT_FOUND of binding.rs (validate_payload_field_references, validate_entity_field_references). It lowers the file with program/read and walks, in every inline trait, the guard, the effects and the ensures of each transition (payload and entity-field reads), the state holds and the tick effects (entity-field reads), and the entity invariants. A @payload.<path> read must resolve through the payload schema the transition's event declares, descending into each matched field's properties; an event without a schema gets the lifecycle or the declare-in-emits suggestion. An @entity.<field> read must name a field of the trait's linked entity (id, createdAt and updatedAt are runtime-managed), an @EntityName.<field> read a field of that entity; an @fromEntity.<field> read in an ensures is checked as @entity.<field>. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint binding-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-binding-roots.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-binding-roots [
   version: "1.0.0",
   inbound: ["cli-lint-binding-roots"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-binding-roots - the `orb lint binding-roots <file>` command, the port of the root rules of binding.rs validate_binding: ORB_BINDING_INVALID_FORMAT, ORB_BINDING_FROM_ENTITY_OUTSIDE_ENSURES, ORB_BINDING_DISPATCH_ROOT_IN_TICK, ORB_BINDING_ROOT_NO_PATH, ORB_BINDING_EVENT_INVALID_PATH, ORB_BINDING_STATE_NO_PATH, ORB_BINDING_NOW_NO_PATH and ORB_BINDING_UNKNOWN_ENTITY. It lowers the file with program/read and walks the guard (guard context), the effects (effect context), the ensures (ensures context), the state holds and the entity invariants (guard context) of every inline trait, and the tick effects (tick context). Every `@root` binding string is checked unless 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` binds its root. The delivery roots (event, prevEvents, prevStates, fromState, toState) and the `@event.source` keys are the language's delivery record. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint binding-roots: 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-binding-setters.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-binding-setters [
   version: "1.0.0",
   inbound: ["cli-lint-binding-setters"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-binding-setters - the `orb lint binding-setters <file>` command, the port of the write-side binding rules of binding.rs: ORB_BINDING_ENTITY_FIELD_NEVER_SET, ORB_BINDING_PERSIST_ROW_ID_NEVER_SET (validate_entity_fields_have_setters), ORB_BINDING_EMBED_READS_ARM_WRITE (validate_embed_reads_arm_writes) and the call-site capture half of ORB_BINDING_PAYLOAD_FIELD_UNDECLARED (validate_callsite_payload_captures). It lowers the file with program/read, asks std-orb-lint-input's OrbLintExprNodes for the flat typed nodes of every guard, effect, tick effect and config default (LINT_EXPR_ASK / LINT_EXPR_NODES), reads the whole bindings (`@entity.<field>`, `@trait.<Child>`, `@callsitePayload.<path>`) and the `set` and `persist` calls from those nodes, and, per orbital, indexes the sites where a transition renders an embedded trait (`@trait.<Child>` in its guard or effects) with the fields that transition sets, the values it sets and the payload its event declares. Every @entity.<field> a trait reads (guard, effects, tick effects) must be set by a (set @entity.<field> ...) somewhere in the trait, unless the field is intrinsic or has a declared default, a trait on the same [shared] entity sets it, or a rendering parent on the same entity sets it. A persist update or delete of the whole @entity needs a (set @entity.id ...). A render-only child of a persistent, non-shared entity that reads an @entity field its composing transition writes shows the value from before the write. A @callsitePayload.<path> capture must resolve in the payload of some composing event up the embed chain. The lifecycle events the bus never delivers are read from LINT_OPERATOR_SEMANTICS. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint binding-setters: 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-binding-traits.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-binding-traits [
   version: "1.0.0",
   inbound: ["cli-lint-binding-traits"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-binding-traits - the `orb lint binding-traits <file>` command, the port of the @trait.<Name> binding rules of binding.rs (validate_trait_binding_usage, detect_trait_binding_cycles): ORB_BINDING_TRAIT_MISSING_NAME, ORB_BINDING_TRAIT_INVALID_FORMAT, ORB_BINDING_TRAIT_SELF_REFERENCE, ORB_BINDING_TRAIT_UNKNOWN, ORB_BINDING_TRAIT_OUTSIDE_RENDER_UI and ORB_BINDING_TRAIT_CYCLE. It lowers the file with program/read and walks every inline trait: a trait-typed config knob bound to @trait.<Name> must name a trait of the orbital, and an @trait binding is allowed only inside a render-ui effect (a guard, a non-render effect and a tick get the outside-render-ui error); an allowed binding must be single-segment, name a PascalCase trait of the orbital and not the trait itself. The @trait references of an orbital's transition and tick effects form a graph; the first cycle found by a depth-first walk in declaration order is reported once per orbital. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint binding-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-browser-effects.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-browser-effects [
   version: "1.0.0",
   inbound: ["cli-lint-browser-effects"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-browser-effects — the `orb lint browser-effects <file>` command, the port of the browser/beacon, browser/page-facts, on-device (browser/prompt, browser/embed) and browser/tab-* checks of effect/http.rs (check_beacon_call, check_page_facts_call, check_on_device_call, check_tab_call and the background-tick loop of validate_http_effects), found at any depth of a guard or effect of an inline trait. Everything the operator table states comes from it through std-orb-lint-host-calls (std-orb-lint-input's LINT_OPERATOR_SHAPES and LINT_HOST_FACTS): the keys a beacon request and its options may carry, the facts a page-facts list may name, the operators of the on-device and tab families (`family`), a tab operator's request keys in the order the table declares them, the emit keys of each operator in the order the operator documents them and the default port of each http scheme. Reports ORB_BEACON_URL_NOT_ABSOLUTE (a literal beacon URL that does not begin with http:// or https://), ORB_BEACON_TEXT_REQUIRED (no request, or a request without `text`), ORB_BEACON_OPTION_UNKNOWN (a request or options key the table does not declare; `key` given in both), ORB_PAGE_FACTS_FIELD_INVALID (not a list, an empty list, a word that is not a page fact, a fact listed twice), ORB_ON_DEVICE_SCHEMA_INVALID (a literal browser/prompt response schema that is not a JSON object), the ORB_HOST_EFFECT_ARITY and ORB_HOST_EFFECT_OPTION_UNKNOWN of browser/prompt, browser/embed and every browser/tab-* operator, ORB_TAB_REQUEST_INVALID (a tab request that is not an object or text from data, or carries a key the operator does not declare), ORB_ON_DEVICE_EFFECT_ON_SERVER and ORB_TAB_EFFECT_ON_SERVER (an on-device or tab call in an effect of a `[background]` tick, which runs on the server), ORB_HTTP_ORIGIN_NOT_STATIC and ORB_HTTP_EGRESS_UNDECLARED for the beacon URL (the origin of the URL against the program's `egress`, with the default port of the scheme), and, through std-orb-emit-config, ORB_EFF_EMIT_KEY_INVALID, ORB_EFF_EMIT_INVALID_NAME and ORB_EFF_EMIT_UNDECLARED_EVENT for the `emit` block of each of these operators. Not reported here: the part of ORB_TAB_REQUEST_INVALID that parses a literal tab request as the kernel's tab-call parser reads it (a request whose keys are all declared and whose values the parser refuses); the key and cancelled findings, which 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 browser-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-call-service.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-call-service [
   version: "1.0.0",
   inbound: ["cli-lint-call-service"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-call-service — the `orb lint call-service <file>` command, the port of effect/call_service.rs (validate_call_service, check_array_call, check_service_name, check_action, check_params, walk_nested_call_services): every `call-service` (or `call_service`) form of an inline trait's transition or tick, at the path the compiler reports it. A call-service that is itself an effect is checked where it stands, inside the do, if, when and let effect-sequencing forms too (at `<effect>.do[i]`, `.then`, `.else`, `.body[i]`, a branch written as a list adding `[k]`); a call-service nested in the arguments of an effect, in the condition of an if or when, or in a let value is checked at the path of the effect that holds it. Service names, actions, params and the response shape come from the installed services registry (std-orb-lint-service-registry), and the program's own `services` when it declares any. Reports ORB_EFF_CALL_SERVICE_MISSING_SERVICE (fewer than two arguments, a service name that is not text, a service the program's `services` does not define), ORB_EFF_CALL_SERVICE_UNKNOWN_SERVICE (a service the registry does not know), ORB_EFF_CALL_SERVICE_MISSING_ACTION (an action that is not text, or not an action of the service; a declared-only service has no action list to check), ORB_EFF_CALL_SERVICE_UNKNOWN_PARAM (an args key the action does not declare, the envelope keys emit, onSuccess, onError and timeout excepted), ORB_EFF_CALL_SERVICE_MISSING_PARAM (a required param the args object lacks), ORB_EFF_CALL_SERVICE_PARAM_TYPE (a literal of another kind than the declared type; a binding or call is not checked) and ORB_CALL_SERVICE_RESULT_HAS_KEY (a keyed call to an action whose response already has a `key` field). The object form `{ call_service: { … } }` of an effect (written only in .orb documents), the key findings are not reported here. The `emit` block of the trailing options of a call-service that is itself an effect is checked through std-orb-emit-config against the emit keys of the operator table, which std-orb-lint-input sends as LINT_HOST_FACTS (ORB_EFF_EMIT_KEY_INVALID, ORB_EFF_EMIT_INVALID_NAME, ORB_EFF_EMIT_UNDECLARED_EVENT). Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint call-service: 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-circuit-client-bound.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-circuit-client-bound [
   version: "1.0.0",
   inbound: ["cli-lint-circuit-client-bound"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-circuit-client-bound - the `orb lint circuit-client-bound <file>` command, the port of the checks validate_closed_circuit runs only on client-bound traits (circuit/closed_circuit.rs): a trait a route page declares plus the transitive closure of the traits it embeds as `@trait.<Name>` in config defaults, guards, effects and ticks. ORB_CIRCUIT_FAILURE_ARM_MISSING and ORB_CIRCUIT_FAILURE_ARM_RENDERS_NOTHING (a transition whose fetch, persist, call-service or other failureOps effect declares `emit: { failure: X }` lands in a state with no arm for X, or whose arms neither paint nor emit a declared event or inbound answer), ORB_CIRCUIT_MODAL_SHELL_CLOSE_DEAF and ORB_CIRCUIT_SELF_OVERLAY_IN_SHELL (a pattern painted into an overlay slot whose state has no CLOSE or CANCEL arm; a self-overlaying node reachable through children or a registry node-typed prop of an overlay payload) and ORB_CIRCUIT_DEAD_BODILESS_ACTION (an effect-less arm that leaves a state some other arm painted a main slot for). It also reports ORB_T_TRAIT_UNMOUNTED: in a program (an orbital with pages, or any orbital of a file with more than one non-spec orbital), a trait with transitions that no page of any orbital lists, directly or through the @trait embed closure, is never mounted; the suggestion names the page that already mounts one of its embedded children. The overlay, main and self-overlay vocabularies and the failure operator list are the rule's knobs. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint circuit-client-bound: 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-circuit-emits.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-circuit-emits [
   version: "1.0.0",
   inbound: ["cli-lint-circuit-emits"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-circuit-emits - the `orb lint circuit-emits <file>` command, the port of three per-trait checks of validate_all_circuits (circuit/closed_circuit.rs): ORB_RENDER_ACTION_LIFECYCLE_EVENT (a rendered pattern's event-bearing prop, found by the installed pattern registry's event prop names at any depth of the render-ui props, that names an event the bus never delivers: the operator table's emit busExcluded list), ORB_CIRCUIT_LIFECYCLE_EMIT_UNDELIVERED (an `(emit EVENT)` effect, nested at any depth of the transition's effect arrays, of such an event) ORB_CIRCUIT_OWN_EMIT_UNREACHABLE (an `(emit EVENT)` effect with a literal event, nested at any depth of the transition effect arrays but not inside another effect's options object, of an event the same trait handles in some arm but from no arm whose from-states include the transition's target state, so the same-trait cascade never delivers it) and ORB_CIRCUIT_SELF_EMIT_LOOP (a transition arm that re-emits its own trigger event while a same-event arm is enterable from its target state and the emit's payload shows no per-hop progress: no @payload reference, and no @entity reference together with an @entity set in the same arm). Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint circuit-emits: 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-circuit-graph.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-circuit-graph [
   version: "1.0.0",
   inbound: ["cli-lint-circuit-graph"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-circuit-graph - the `orb lint circuit-graph <file>` command, the port of the state-graph and overlay-exit checks of validate_closed_circuit (circuit/closed_circuit.rs). For every inline trait it reports CIRCUIT_UNREACHABLE_STATE (a non-initial state no transition enters), CIRCUIT_DEAD_END_STATE (a state no transition leaves by name that is not marked isTerminal), CIRCUIT_NO_OVERLAY_EXIT (a state that paints a pattern into an overlay slot and has no transition that closes the slot or lands in a state that does not paint it) and CIRCUIT_MODAL_EXIT_INCOMPLETE (a transition from an overlay state into a main-painting state that closes the overlay without repainting main, and a transition that leaves a state mounting an overlay slot without a `(render-ui <slot> null)` for it). The overlay slot names are the rule's overlaySlots knob and the exit events of the suggestion its exitEvents knob. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint circuit-graph: 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-circuit-item-actions.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-circuit-item-actions [
   version: "1.0.0",
   inbound: ["cli-lint-circuit-item-actions"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-circuit-item-actions - the `orb lint circuit-item-actions <file>` command, the port of the item-action checks of validate_closed_circuit (circuit/closed_circuit.rs). For every render-ui effect of a transition (a top-level effect painting a typed pattern payload) it reads the descriptors of the pattern's `itemActions` and `actions` props through std-orb-value-leaves (every leaf of the value, a descriptor list or a single descriptor; an action is a descriptor with an event string and an action, event or label string) and reports CIRCUIT_ORPHAN_EVENT (an action whose event no transition of the trait, no transition or listens route of the orbital and no declared emit of the trait carries), CIRCUIT_DEAD_HANDLER (an action whose event the trait handles, but not from the state the action is rendered in nor from a wildcard) and CIRCUIT_DUPLICATE_EVENT (the same event twice in one render-ui effect, branch and slot). It also reports CIRCUIT_ACTION_COMPONENT_MISMATCH (a non-record-scoped action that the affinity knob lists as invalid for its component, and a form or list action in a state whose painted patterns include no form or list pattern; an itemActions entry, and an actions entry on a pattern whose entity prop declares record cardinality in LINT_PATTERNS, is record-scoped and exempt); the affinity table, form and list patterns and actions are the rule's knobs. CIRCUIT_DEAD_END_COMPONENT is retired: its interactive-pattern set has been empty since G-ORB-053. A value with several leaves reports its paths with a .branch[i] suffix. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint circuit-item-actions: 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-circular-dependencies.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-circular-dependencies [
   version: "1.0.0",
   inbound: ["cli-lint-circular-dependencies"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-circular-dependencies — the `orb lint circular-dependencies <file>` command, the port of validate_circular_dependencies (circuit/cross_orbital/cycles.rs, ORB_X_CIRCULAR_DEPENDENCY). It builds an event-level graph whose node is (trait, event its arm receives): an arm's emits (an `(emit X)` effect at any array depth, an object carrying `emit: X`, and the `emit` map values of a fetch or persist effect) reach the arms a `listens` route triggers. A route is an edge only when it can propagate (some transition on its trigger has an emit effect or an emit-carrying effect option), is not a lifecycle trigger (INIT, LOAD, RESET), the emitter is another trait, the route's source matches the emitter, neither the emitting arm nor the listen carries a guard (a guard names the loop's exit), and an edge across orbitals needs the emitter's `scope: external` emit, an externally scoped listen or an orbital-sourced listen. The first cycle found by a depth-first walk in sorted node order is reported once at `traits` with its node path (the Rust walk follows hash order, so the path it prints is not stable; this lint's path is). Reports ORB_X_CIRCULAR_DEPENDENCY (status 500, exit 1). Clean answers `lint circular-dependencies: 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-client-tick-locality.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-client-tick-locality [
   version: "1.0.0",
   inbound: ["cli-lint-client-tick-locality"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-client-tick-locality — the `orb lint client-tick-locality <file>` command, the port of ORB_T_CLIENT_TICK_NOT_LOCAL (traits/client_tick_locality.rs). It lowers the file with program/read and, for every orbital's inline primary or auxiliary entity declared `runtime` that an inline trait bound to it ticks on the client (a tick not declared runsInBackground), reports each bound trait that writes the ticked frame (the ticking trait itself, and for a `shared` entity every bound trait) and declares neither the client nor the optimistic dispatch mode, at `orbitals.<Orbital>.traits.<Trait>` with the Rust message and suggestion (status 500, exit 1). A trait is bound to the entity named by its linkedEntity, else to the orbital's inline primary entity. A persisted entity or a background tick is not reported. Clean answers `lint client-tick-locality: 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-collection-policy.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-collection-policy [
   version: "1.0.0",
   inbound: ["cli-lint-collection-policy"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-collection-policy — the `orb lint collection-policy <file>` command, the port of ORB_S_COLLECTION_POLICY_CONFLICT (entity_access.rs validate_collection_policy_agreement). It lowers the file with program/read and reports each entity that binds a persistent collection already bound by an earlier entity with different @read/@create/@update/@delete directives (status 500, exit 1). Clean answers `lint collection-policy: 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-composed-wiring.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-composed-wiring [
   version: "1.0.0",
   inbound: ["cli-lint-composed-wiring"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-composed-wiring - the `orb lint composed-wiring <file>` command, the port of ORB_COMPOSED_STATE_UNREACHABLE and ORB_COMPOSED_TRANSITION_UNREACHABLE (composition/composed_wiring.rs validate_composed_wiring). For every composed trait (one with sourceBehavior) with a state machine it follows the transitions from the initial state (the first isInitial state, else the first state) over the events the program can produce: std-orb-fired-events' control and effect events of every trait, the strings of every event-typed config default, the bus-excluded events, the trait's listens triggers, its events declared input and, when a transition paints a non-self-overlaying pattern into an overlay slot, the shell dismiss events. A transition whose guard folds statically false with the trait's literal config knobs substituted is off. ORB_COMPOSED_STATE_UNREACHABLE reports the states no event leads to that a live transition on an unproduced event enters; ORB_COMPOSED_TRANSITION_UNREACHABLE reports the unproduced, undeclared events a live transition from a reached state into a reached state waits on. The overlay, self-overlay and shell dismiss vocabularies are the rule's knobs. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint composed-wiring: 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-computed-key-dot-path.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-computed-key-dot-path [
   version: "1.0.0",
   inbound: ["cli-lint-computed-key-dot-path"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-computed-key-dot-path - the `orb lint computed-key-dot-path <file>` command. A COMPUTED key of object/get, object/has or object/set is read as ONE whole key; only a literal string key is a dotted path. A key built with str/concat from a string literal containing \".\" was written as a path and now names a single key, so the read misses or the write adds a flat entry. Each such call in a guard, an effect or a tick effect of a trait is an error ORB_COMPUTED_KEY_DOT_PATH at the transition or tick. Literal path keys and keys joined with another separator are clean. Clean answers `lint computed-key-dot-path: clean` (status 200, exit 0); findings fail the run (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-config-dangling-ref.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-config-dangling-ref [
   version: "1.0.0",
   inbound: ["cli-lint-config-dangling-ref"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-config-dangling-ref — the `orb lint config-dangling-ref <file>` command, the port of ORB_CONFIG_DANGLING_REF (validate_dangling_config_refs, types/config_type.rs). It lowers the file with program/read and, per orbital, collects the `@config.<key>` tokens an inline trait uses in its config defaults, transition effects and tick effects (a token that is the self-named default of a prop the installed pattern registry declares for its pattern is a declaration default, not a forward), and reports each key (sorted) that no knob can supply: not an app-level or orbital-level `config {}` knob, and not declared by the trait itself (unless the key is the trait's own self-forward) or by any trait connected to it through `@trait.<Name>` embeds in either direction. It reports at `orbitals[<i> (<orbital>)].traits[<j> (<trait>)]` with the compiler's message and suggestion (status 500, exit 1). Clean answers `lint config-dangling-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-config-knob.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-config-knob [
   version: "1.0.0",
   inbound: ["cli-lint-config-knob"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-config-knob — the `orb lint config-knob <file>` command, the port of the per-knob declaration checks of validate_config_field (types/config_type.rs). It lowers the file with program/read and, for every config knob of every inline trait, reports ORB_T_CONFIG_OBJECT_ARRAY_FORBIDDEN (a knob typed `object` or `[object]`), ORB_T_CONFIG_TIER_INVALID (a `@tier` outside domain, policy, infra, presentation, internal), ORB_T_SECRET_DEFAULT_NOT_STRING (a `secret` knob whose default is not a string), ORB_T_INVALID_EVENT_DEFAULT (an `event` knob whose default names no event of the trait's event set, holds a Trait.EVENT address while it defines an emitted event, or is neither a string nor a computed value) ORB_T_INVALID_PATTERN_DEFAULT (a `pattern` knob whose default is no installed pattern) and ORB_T_INVALID_SLOT_DEFAULT (a `slot` knob whose string default is not one of the slots in LINT_UI_VOCAB; an unreadable vocabulary answers ORB_LINT_UI_VOCAB_UNREAD at the knob), at `orbitals[<i> (<orbital>)].traits[<j> (<trait>)].config(<knob>)` with the compiler's message and suggestion (status 500, exit 1). A `field`, `[field]`, `render-ui` or `node` knob is checked for tier and type only, as the compiler does. Clean answers `lint config-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-config-role-lists.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-config-role-lists [
   version: "1.0.0",
   inbound: ["cli-lint-config-role-lists"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-config-role-lists - the `orb lint config-role-lists <file>` command, the port of check_config_role_lists (identity/user_identity.rs, ORB_S_ROLE_LITERAL_NOT_MEMBER) over the compiler's role_list_sites dataflow (inline/rewrite.rs). It lowers the file with program/read. For each inline trait with a config block (an authored trait when the identity shape is the orbital's own expects shape), against the roster's closed-vocabulary fields (the declared [identity] entity, else the orbital's expects entity [identity] { shape }): a knob list is a role-list site when the trait tests membership in it against a role source, either `(array/includes @config.K <role source>)` (the knob is the list) or `(array/includes (object/get @p <key>) <role source>)` inside a `(fn p ...)` over a collection that resolves to knob K (a `@config.K`, a pass-through of one whose value-source slot lists the single argument N, as the installed operator table declares it, or `(object/get @q <key>)` of an outer element), where a role source is `@user.<role field>` or `@config.V` whose default is such a read. Sites are searched in transition guards and effects, tick guards and effects, listen guards and payload mappings, and every knob default. Every string literal of a site's list in the knob's default that is not a declared member of the role field is reported at <trait path>.config.<knob>. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint config-role-lists: 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-control-unhandled.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-control-unhandled [
   version: "1.0.0",
   inbound: ["cli-lint-control-unhandled"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-control-unhandled - the `orb lint control-unhandled <file>` command, the port of validate_controls_handled (final_program.rs, G-ORB-187), the `orb validate --final` rule: a control event that a trait's rendered patterns fire (std-orb-fired-events' byControl, which already drops provably false branches and bus-excluded names) reaches the rendering trait and every trait that embeds it, directly or transitively through any referrer (std-orb-embed-chain's embedders) plus every `listens` route out of them. A control none of those handle, by a transition of the trait or a host, or by a listens route (an `any` source, or a trait or orbital source naming one of them, on the orbital or on any trait), does nothing when operated: ORB_EMIT_CONTROL_UNHANDLED at orbitals.<O>.traits.<T>. An event named by an emits entry carrying a definerKnob is the atom offering an affordance and is exempt. The finding reads its code from the rule's `codes` knob. Clean answers `lint control-unhandled: 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-control-value-discarded.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-control-value-discarded [
   version: "1.0.0",
   inbound: ["cli-lint-control-value-discarded"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-control-value-discarded - the `orb lint control-value-discarded <file>` command, the port of ORB_CONTROL_VALUE_DISCARDED (composition/composed_wiring.rs validate_composed_wiring and discarded_offered_values). For every composed trait (one with sourceBehavior) it reads the events its rendered value controls fire: in every effect tree, an object whose `type` (or the string default of the `@config.<knob>` it names) is a pattern with value controls (std-orb-lint-input's LINT_VALUE_CONTROLS: the event or event-ref props that are not notifications and, for a `fieldsContract: form` pattern every one, otherwise the ones declaring an emitPayloadSchema) contributes the event named by each such prop, resolved through the trait's own string config defaults. An event the trait declares with a payload is discarded when no sibling trait of the trait's embedder closure (std-orb-embed-chain's embedders) has a transition for it, no `listens` route of the orbital or of any of its traits reaches that closure (an `any` source, or a trait or orbital source naming a trait of it), no other orbital routes it by naming this orbital and this trait, and its own arms for it keep nothing: no guard reads the payload (`@payload` or a `?` binding), no effect reads the payload except through a `set` of a runtime entity field that no trait bound to that entity reads (guards, transition effects and tick effects), and no effect holds a persist, call-service or emit. An event the trait declares `-> external` itself is an embedder output: its value goes to the embedder and it is never reported. An event whose external scope a composer overrode (scopeOverridden) defers to an importer and is reported only for a finished program under rule control-value-discarded-final (`orb validate --final`); every other discarded event is reported under rule control-value-discarded. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint control-value-discarded: 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-cross-duplicate-entity.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-cross-duplicate-entity [
   version: "1.0.0",
   inbound: ["cli-lint-cross-duplicate-entity"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-cross-duplicate-entity — the `orb lint cross-duplicate-entity <file>` command, the port of ORB_X_DUPLICATE_ENTITY. It lowers the file with program/read and reports each inline entity name declared by more than one orbital, once, with the orbital names (status 500, exit 1). Clean answers `lint cross-duplicate-entity: 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-cross-emitter.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-cross-emitter [
   version: "1.0.0",
   inbound: ["cli-lint-cross-emitter"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-cross-emitter — the `orb lint cross-emitter <file>` command, the port of validate_cross_emitter (circuit/cross_emitter.rs, ORB_X_CROSS_EMITTER_DECLARED_PAYLOAD_MISMATCH). Every inline trait's `emits` entries are grouped by event; an event declared by two or more emitters must carry the same payload signature, the set of (field name, field type, required) triples of the declared payloadSchema. A render-emitter's declared payload is replaced by what its first render-ui node sends: a pattern node whose event prop (the LINT_PATTERNS payloadFor pairing, the named prop of kind event) equals the event and whose paired payload prop is an object, each key typed from the linked entity when the value is `@entity.<field>` and string! otherwise (number and boolean literals by their own type). A group is checked only when some listener of the event can see more than one emitter: a `*` source, or an orbital-pinned source naming one of the group's (orbital, trait) emitters from a different orbital. Each emitter after the first whose signature differs from the first is reported once at `<first trait path> vs <trait path>`; events are reported in name order. Clean answers `lint cross-emitter: 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-cross-registry.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-cross-registry [
   version: "1.0.0",
   inbound: ["cli-lint-cross-registry"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-cross-registry — the `orb lint cross-registry <file>` command, the port of validate_cross_registry (composition/cross_registry.rs). It walks every inline trait's transition guards and effects and tick effects as expression trees and reports, in walk order, SEXPR_INVALID_OPERATOR for a namespaced head (it contains `/`) that is not an installed operator (LINT_OPERATOR_NAMES) and is not an `agent/` or `behavior/` call, and the ambiguous bare `concat` head (str/concat or array/concat), with the compiler's did-you-mean suggestion (the same basename under another namespace, else the closest operator name within edit distance 2, else the `orb signatures` hint); ORB_RUI_INVALID_PATTERN for a render-ui whose first object argument names a `type` that is not in the installed pattern registry (LINT_PATTERNS), at `[<arg index>].type`; and SEXPR_INVALID_OPERATOR for an unresolved `behavior/<name>` call (a composer `compose`, `wire`, `detect-layout` or `pipe` names its behavior in its first argument unless that starts with `@`, and a registered operator such as `behavior/ref` is a verb, not a behavior) naming a behavior no installed package ships. The installed behavior names are read only when such a call exists, from behavior/packages and one behavior/catalog per package (a package whose catalog fails ships nothing, as in the compiler). Clean answers `lint cross-registry: 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-derived-field-write.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-derived-field-write [
   version: "1.0.0",
   inbound: ["cli-lint-derived-field-write"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-derived-field-write — the `orb lint derived-field-write <file>` command. A field declared `@derived <expr>` is computed by the kernel on every write, so a `(set @entity.<field> …)` in a trait bound to its entity, or a `persist create|update|upsert` (single or in a batch) whose data names it, is [ORB_DERIVED_FIELD_WRITTEN]. Clean answers `lint derived-field-write: 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-dispatch-contract.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-dispatch-contract [
   version: "1.0.0",
   inbound: ["cli-lint-dispatch-contract"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-dispatch-contract - the `orb lint dispatch-contract <file>` command, the port of the dispatch-contract checks of entities/entity_mutation.rs. A `[client]` trait (dispatch client): ORB_T_LOCAL_TRAIT_TOUCHES_SERVER for a transition whose guard reads `@user` and for each transition or tick effect that runs a server-bound effect (a transition whose guard is statically false is skipped); ORB_T_LOCAL_ON_NON_SHARED_PERSISTENT when it writes its linked entity (a `set @entity.<f>` anywhere, or a `persist create|upsert|update` of it in a transition, following `persist batch` list builders) while that entity is neither `[shared]` nor client-resident (`[runtime]` or browser-stored). An `[optimistic]` trait: ORB_T_CLIENT_TICK_SERVER_EFFECT for a tick that is not `[background]` and carries a server-bound effect, reported at the tick's effects. A trait with a declared dispatch: ORB_AUTH_GUARD_CLIENT_ONLY (a warning) for a transition guard that reads `@user` while the transition runs server-bound effects, unless every arm of its (from, event) pair runs the same server-bound effects. Where an effect runs follows effect_site (the sites and entity params come from LINT_OPERATOR_SHAPES, the browser-stored entities from the resolved program): an operator whose installed runsOn is server stays server except a `persist batch` whose named entities are all browser-stored, a data effect on a literal browser-stored entity, a `program/live` whose literal options name `kind: \"trace\"`, `cancel-call` and a `program/self` whose literal options name `mounted: true`, which the kernel places at run time (EXEC-DIST-14, EXEC-DIST-15); an `if` or `when` branch whose condition is statically false is dead, and a `let` pair name or `fn` parameter list is never a call. It needs the RESOLVED program (program/read resolve). Findings print as `[code] path: message` (status 500, exit 1); clean answers `lint dispatch-contract: 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-duplicate-transition.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-duplicate-transition [
   version: "1.0.0",
   inbound: ["cli-lint-duplicate-transition"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-duplicate-transition — the `orb lint duplicate-transition <file>` command, the port of ORB_T_DUPLICATE_TRANSITION (trait_validator.rs validate_transitions). It lowers the file with program/read and, for every inline trait, groups the transitions that name one source state and one event (each state of a list `from` is its own source). A group of more than one with fewer than size-1 guarded arms reports duplicates without guards; otherwise a group where two guarded arms carry an equal guard reports the same guard. One finding per group at its first arm, with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint duplicate-transition: 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-duplicate-use-alias.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-duplicate-use-alias [
   version: "1.0.0",
   inbound: ["cli-lint-duplicate-use-alias"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-duplicate-use-alias — the `orb lint duplicate-use-alias <file>` command, the port of ORB_O_DUPLICATE_USE_ALIAS (inline/mod.rs inline_orbital). It lowers the file with program/read and, for every orbital, reports the first `uses` declaration whose alias an earlier declaration of the same orbital already took (one finding per orbital, as the Rust check stops at the first), at `orbitals[name=<orbital>].uses[<i>]`, with the Rust message (status 500, exit 1). Clean answers `lint duplicate-use-alias: 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-effect-forms.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-effect-forms [
   version: "1.0.0",
   inbound: ["cli-lint-effect-forms"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-effect-forms - the `orb lint effect-forms <file>` command, the port of the structural checks of the set, fetch, fetch-stream and persist effects (expressions/effect/set.rs, fetch.rs, persist.rs). The effects of every inline trait transition and tick are flattened by std-orb-effect-leaves (through do, if, when and let). The `@entity.<field>` references of an entity's `@create` policy come from std-orb-lint-input's OrbLintExprNodes (LINT_EXPR_ASK / LINT_EXPR_NODES). set: ORB_EFF_SET_INVALID_BINDING, ORB_EFF_SET_PAYLOAD_NOT_ALLOWED, ORB_BINDING_SET_TARGET_MISSING_PATH and ORB_X_ENUM_VALUE_NOT_MEMBER (a string literal assigned to an enum field of the trait's linked entity, or held by an enum field of the record literal set into a to-one relation field, read against the related entity). fetch and fetch-stream: ORB_EFF_FETCH_INVALID_ENTITY (an undeclared entity, a non-string name, a raw binding as third argument, too many arguments), ORB_EFF_FETCH_INVALID_INCLUDE and ORB_EFF_FETCH_INVALID_OPTION (deliver, total and the nearest structure). persist: ORB_EFF_FETCH_INVALID_ENTITY, ORB_PERSIST_ID_NOT_A_PATH, ORB_PERSIST_CREATE_LITERAL_ID, ORB_ENTITY_INTRINSIC_FIELD_PERSISTED, ORB_PERSIST_CREATE_MISSING_POLICY_FIELD and ORB_PERSIST_WHERE_NOT_A_PREDICATE, and for the data literal of a persist create, update or upsert the row-literal checks against the target entity: ORB_X_ROW_LITERAL_UNKNOWN_FIELD (a key the entity does not declare; also a key of the record literal set into a to-one relation field, read against the related entity) and ORB_X_ROW_LITERAL_MISSING_REQUIRED (a persist create literal omitting a required, default-less, non-nullable, non-intrinsic field), ORB_X_ROW_LITERAL_FIELD_TYPE_MISMATCH (a null literal into a field that is not declared nullable, or a string, number or boolean literal into a field of another scalar type; the same two checks apply to each value of a record literal set into a to-one relation field). Each finding carries the Rust path, message and suggestion (status 500, exit 1). The rule asks std-orb-effect-leaves for the set, fetch, fetch-stream and persist effects (heads) and reads every argument, literal and object key from their flat typed nodes; the operations of a persist batch are checked from the batch's own nodes, after the effects themselves. Clean answers `lint 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-egress-scheme-unused.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-egress-scheme-unused [
   version: "1.0.0",
   inbound: ["cli-lint-egress-scheme-unused"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-egress-scheme-unused — the `orb lint egress-scheme-unused <file>` command, the os-grants-family check of the app `egress` list. The TCP protocol-target grants were retired (G-ORB-586): an entry with the scheme redis, rediss, postgres or postgresql grants nothing, because no operator or fetch uses it (the Redis and Postgres wires are std-resp-client and std-row-store-postgres over os/tcp-connect, and a socket is granted by a net entry). It lowers the file with program/read and reports each such entry, naming the net-grant replacement (net: { \"host:port\": [tcp] }, the entry's own host and port). Clean answers `lint egress-scheme-unused: 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-embed-config-forward.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-embed-config-forward [
   version: "1.0.0",
   inbound: ["cli-lint-embed-config-forward"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-embed-config-forward — the `orb lint embed-config-forward <file>` command, the port of ORB_EMBED_CONFIG_FORWARD_MULTI_REFERRER (validate_embed_config_forward_multi_referrer, types/config_type.rs). It lowers the file with program/read and, per orbital, finds the inline traits embedded through `@trait.<Name>` (in a config default, a transition guard or effect, or a tick guard or effect; the token ends at a `.` or `[`) by two or more other traits; when such a trait declares an `@config.<knob>` forward (a knob whose whole default is one, or one nested in a default naming a knob the trait does not declare itself) it reports the trait once at `<trait>.@trait` with the referrers sorted, the compiler's message and suggestion (status 500, exit 1). Clean answers `lint embed-config-forward: 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-emit-config-ref.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-emit-config-ref [
   version: "1.0.0",
   inbound: ["cli-lint-emit-config-ref"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-emit-config-ref — the `orb lint emit-config-ref <file>` command, the port of ORB_EMIT_CONFIG_REF_INVALID. It lowers the file with program/read and, for every inline trait emit named `@config.<knob>`, checks the Option B contract: the knob is a declared config field (else unknown), string- or event-typed (else not string), carries a default (else no default) and that default is a string literal (else not string). Each failure is reported with its path and suggestion (status 500, exit 1). Clean answers `lint emit-config-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-emit-declaration.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-emit-declaration [
   version: "1.0.0",
   inbound: ["cli-lint-emit-declaration"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-emit-declaration — the `orb lint emit-declaration <file>` command, the port of validate_emit_against_declaration (effect/emit_declaration.rs). It lowers the file with program/read and checks each `emit` effect of every inline trait transition and tick, however nested in do, if, when and let (std-orb-effect-leaves flattens them): an event the trait's `emits` array does not declare is ORB_T_EVT_UNDECLARED, and an emit of a declared external event that carries a payload object missing a required payload field (or carries a non-object payload while the event has required fields) is ORB_X_PAYLOAD_MISMATCH, each with the Rust path, message and suggestion (status 500, exit 1). ORB_EFF_MISSING_REQUIRED_EMIT (validate_required_emit_success) is not here: no operator in the table sets requiresEmitSuccess, so the Rust pass is inert. The rule asks std-orb-effect-leaves for the emit effects (heads: emit) and reads the event name and the payload object's keys from their flat typed nodes. Clean answers `lint emit-declaration: 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-emit.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-emit [
   version: "1.0.0",
   inbound: ["cli-lint-emit"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-emit — the `orb lint emit <file>` command, the port of validate_emit (effect/emit.rs). It lowers the file with program/read and walks the effects of every inline trait transition and tick, descending through the do, if, when and let effect-sequencing forms, and checks each `emit` effect: no event name is CIRCUIT_ORPHAN_EVENT, a string that is not an identifier (a letter, then letters, digits and underscores) is ORB_T_EVT_INVALID_NAME, and a first argument that is an object, a list, a number, a boolean or null is ORB_EFF_EMIT_INVALID_NAME, each with the Rust path, message and suggestion (status 500, exit 1). The emit config blocks of the async operators belong to those operators' own lints. The rule asks std-orb-effect-leaves for the emit effects (heads: emit) and reads each one from its flat typed nodes (std-orb-lint-input's OrbLintExprNodes: the event name is the second child, a number, a boolean or null is a literal node carrying its JSON text). Clean answers `lint emit: 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-empty-event-name.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-empty-event-name [
   version: "1.0.0",
   inbound: ["cli-lint-empty-event-name"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-empty-event-name — the `orb lint empty-event-name <file>` command, the port of ORB_T_EMPTY_EVENT_NAME (trait_validator.rs validate_state_machine). It lowers the file with program/read and, for every inline trait with at least one state, reports an empty key in stateMachine.events, an empty event in the trait emits and an empty event in stateMachine.transitions, in that order, each with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint empty-event-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-engine.lolo

@@ -1,7 +1,7 @@
 app std-orb-lint-engine [
   version: "1.0.0",
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-engine — the rule engine of the lint umbrella. For a LINT_RUN { file } it composes every file-taking std-orb-lint-* rule trait (shared-types is left out: it walks the std and io behavior trees and takes no file), asks the lint input to read and lower the file once (LINT_REQUEST), collects LINT_FOUND { rule, findings } from each rule, then asks the input for each lazy child the resolved program split off (LINT_LAZY names them; LINT_CHILD_REQUEST { index } replays every rule on that child, each rule echoing the pass's scope (empty for the program, the child's orbital) so every pass's answers are distinct deliveries (EXEC-QUEUE-4), and a child's findings' paths prefixed `lazy[<scope>].` as the compiler's validate_lazy_children prefixed them) and answers LINT_COLLECTED { findings, found } once every rule answered for the program and every child, or LINT_INPUT_UNREAD when the file cannot be read or lowered. It declares no cli hook: std-orb-lint-all (the `orb lint all` hook) and std-orb-validate and std-orb-compile (the policy lints) compose its orbital."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-access.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-access [
   version: "1.0.0",
   inbound: ["cli-lint-entity-access"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-access — the `orb lint entity-access <file>` command, the port of entity_access.rs (validate_entity_access and validate_owner_columns_scoped). It lowers the file with program/read and reports an entity that declares owner columns pointing at the [identity] entity but no @read (ORB_ENTITY_OWNER_COLUMN_UNSCOPED, silenced by an @read none reason), and in each @read/@create/@update/@delete directive an `@entity.<field>` or `(object/get @entity <field>)` that names no field of the owning entity (ORB_S_ACCESS_POLICY_UNKNOWN_ENTITY_FIELD) or an @intrinsic one (ORB_GUARD_ON_FRAME_FIELD_AUTHORIZES), a binding root other than @entity and @user (ORB_S_ACCESS_POLICY_INVALID_BINDING), a column compared to `@user.id` that is not a relation to an [identity] entity (ORB_S_OWNER_FIELD_NOT_IDENTITY_TYPED), a literal compared against a closed-vocabulary `@user.<field>` that is not a declared member (ORB_S_ROLE_LITERAL_NOT_MEMBER) and an `@user` read in a program declaring no [identity] entity (ORB_S_ACCESS_POLICY_REQUIRES_IDENTITY), with the Rust path, message and suggestion (status 500, exit 1). The `@user.<field>` existence checks (ORB_S_UNKNOWN_IDENTITY_FIELD, ORB_S_EXPECTATION_FIELD_UNDECLARED) are not ported: they need the installed language's Viewer members, which no lint input carries. Clean answers `lint entity-access: 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-entity-browser-storage.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-browser-storage [
   version: "1.0.0",
   inbound: ["cli-lint-entity-browser-storage"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-browser-storage — the `orb lint entity-browser-storage <file>` command, the port of ORB_E_LOCAL_REQUIRES_PERSISTENT and ORB_E_IDENTITY_LOCAL (entity.rs validate_browser_storage; the retired ORB_E_MOCK_SEED_NOT_LOCAL and the mock-plus-instances conflict are not ported). It lowers the file with program/read and reports, per orbital entity, each storage-flag contradiction with its path and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped, as validate_all_entities skips them. Clean answers `lint entity-browser-storage: 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-entity-duplicate-field.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-duplicate-field [
   version: "1.0.0",
   inbound: ["cli-lint-entity-duplicate-field"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-duplicate-field — the `orb lint entity-duplicate-field <file>` command, the port. It lowers the file with program/read and, for every orbital's inline primary and auxiliary entity, reports each field whose non-empty name an earlier field of the same entity already uses, with the Rust path, message and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped, as validate_all_entities skips them. Unnamed fields are skipped. Clean answers `lint entity-duplicate-field: 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-entity-empty-enum.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-empty-enum [
   version: "1.0.0",
   inbound: ["cli-lint-entity-empty-enum"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-empty-enum — the `orb lint entity-empty-enum <file>` command, the port. It lowers the file with program/read and, for every orbital's inline primary and auxiliary entity, reports each top-level field of type enum whose values list is empty or absent, with the Rust path, message and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped, as validate_all_entities skips them. Clean answers `lint entity-empty-enum: 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."
 ]