@almadar/std 17.0.1 → 17.0.2

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

@@ -2,7 +2,7 @@ app std-orb-lint-trait-ref-config [
   version: "1.0.0",
   inbound: ["cli-lint-trait-ref-config"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-trait-ref-config — the `orb lint trait-ref-config <file>` command, the port of validate_trait_ref_config_diagnostics and its collection in phases/inline/trait.rs. For each trait entry that references an imported trait (`Alias.traits.Name`) it pairs the unresolved call site with the upstream trait (std-orb-lint-call-site-input: found by the entry's refId when it carries one and the import holds that id, else by name; read as the compiler's deferred import load sees it when the upstream file declares the trait inline, else from the resolved import) and reports ORB_T_CONFIG_UNKNOWN_CALL_SITE_KEY (a call-site config key that is neither a declared knob of the upstream trait nor a declaration-form knob of the alias), ORB_T_CONFIG_MISSING_REQUIRED_KEY (a `!`-required declared knob the call site omits) and ORB_T_EVENT_RENAME_UNKNOWN_KEY (an `events` rename source naming no event the upstream trait declares, emits, transitions on, or produces: the events std-orb-fired-events finds fired by its effects and controls), at `orbitals[name=<orbital>].traits[<index>]` with the compiler's paths, messages and valid values (status 500, exit 1). The pattern registry and the operator table are read once, by std-orb-lint-input, and only when a rename names an event the declaration alone does not. Clean answers `lint trait-ref-config: 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 call site whose import does not resolve is skipped: the compiler reports that failure itself. A trait entry of an orbital that references a trait declared inline in the same file (by `ref` last segment, else `name`; same-named traits of several orbitals are merged) and carries an `events` rename is also checked: ORB_T_EVENT_RENAME_UNKNOWN_KEY at `orbitals[i (Orbital)].traits[j (label)]` with the rename-map wording of validate_event_renames (the port of that second Rust emitter); an unknown target trait is skipped, and an `@config.K` emit resolves to the trait's own string default."
 ]

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

@@ -2,7 +2,7 @@ app std-orb-lint-trait-refs [
   version: "1.0.0",
   inbound: ["cli-lint-trait-refs"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-trait-refs - the `orb lint trait-refs <file>` command, the port of the trait reference, rebind and uniqueness checks of traits/trait_validator.rs. A trait entry of an orbital without a state machine is a reference: with neither `ref` nor `name` it is ORB_T_INVALID_FORMAT, naming a trait no orbital defines inline (and not a `std/` trait) it is ORB_T_UNDEFINED_TRAIT, and a `linkedEntity` no orbital declares (primary, auxiliary or expected entity) is ORB_E_INVALID_RELATION. An inline trait with an empty name is ORB_T_UNDEFINED_TRAIT at `.name` and an undeclared `linkedEntity` ORB_E_INVALID_RELATION. An inline trait imported from an atom (`sourceBehavior`) and rebound to an entity other than the atom's own is ORB_T_REBIND_TARGET_UNRESOLVED when the target names no entity of the program, else ORB_T_ENTITY_NOT_REBINDABLE when the atom's binding is not `@rebindable`, else ORB_T_REBIND_MISSING_FIELDS for the contract `requires` fields the target entity lacks. A trait name defined by more than one inline trait of the program is ORB_T_DUPLICATE_NAME at `orbitals`, once per name. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint trait-refs: 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-transition-refs.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-transition-refs [
   version: "1.0.0",
   inbound: ["cli-lint-transition-refs"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-transition-refs — the `orb lint transition-refs <file>` command, the port of ORB_T_INVALID_TRANSITION and ORB_T_UNDEFINED_EVENT (trait_validator.rs validate_transitions). It lowers the file with program/read and, for every inline trait with at least one state, reports per transition a source state that is not declared (`*` allowed; list sources checked one by one), a target state that is not declared, and, when the trait declares events, an event other than INIT that is not among them, each with the Rust path and message (the Rust valid-values list is not printed). Status 500, exit 1. Clean answers `lint transition-refs: 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-type-param-sweep.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-type-param-sweep [
   version: "1.0.0",
   inbound: ["cli-lint-type-param-sweep"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-type-param-sweep — the `orb lint type-param-sweep <file>` command, the port of ORB_T_UNRESOLVED_TYPE_PARAM (type_param_sweep.rs validate_type_param_sentinels). It lowers the file with program/read and reports every type-parameter sentinel that survived resolution: a type variable left in an entity field shape, in a trait's emit or event payload field (the `$v`, `[$v]` and bare `@entity` sentinels, deferred when the linked entity is licensed by the orbital's expects), in a config knob's items or properties or in the knob's own type, and a config knob still typed with an unresolved sigil (`@user`, `@payload(..)`, `@entity(..)`, `@entity`), with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint type-param-sweep: 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-unsigned-guard.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-unsigned-guard [
   version: "1.0.0",
   inbound: ["cli-lint-unsigned-guard"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-unsigned-guard — the `orb lint unsigned-guard <file>` command: a literal `allowUnsigned: true` on a `jws/verify` call accepts an alg:none token, so the transition holding it must be env-guarded or it is an error (ORB_EFF_UNSIGNED_NOT_ENV_GUARDED). It lowers the file with program/read and reads every inline trait's transitions. A transition is env-guarded when its event is the success answer of an `os/getenv` effect of the trait and its guard compares the answered value (`=` over a `@payload.value` read, alone or as an argument of `and`), or when its event has no listens source, at least one transition of the trait names it as a literal in its effects (an `emit`, or the answer name of a fetch, persist or os/getenv) and none of those transitions is unguarded: guard is propagated from the env-guarded answer arms along those naming edges, a transition reached by no guarded arm (a cycle with no guarded entry) is not guarded, and any transition that is not guarded and has a listens-sourced event or no naming transition taints everything it names. Only inline traits are read; an event named only by a computed expression is not tracked. Clean answers `lint unsigned-guard: 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-untyped-array.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-untyped-array [
   version: "1.0.0",
   inbound: ["cli-lint-untyped-array"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-untyped-array — the `orb lint untyped-array <file>` command, the port of ORB_X_UNTYPED_ARRAY (array payload fields declare an element type). It lowers the file with program/read and checks the payload fields of every trait emit and event, through nested properties at any depth with tree/fold, and the top-level fields of each non-spec orbital's primary and auxiliary entities (an array without items, reported at `.items`). Status 500, exit 1. Clean answers `lint untyped-array: 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-user-field-exists.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-user-field-exists [
   version: "1.0.0",
   inbound: ["cli-lint-user-field-exists"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-user-field-exists - the `orb lint user-field-exists <file>` command, the port of the `@user.<field>` existence checks of user_identity.rs (check_field_exists, walked over every inline trait) and entity_access.rs (unknown_user_field, walked over the @read/@create/@update/@delete directives of every inline entity). It lowers the file with program/read and reports an `@user.<field>` (and, in an access directive, `(object/get @user <field>)`) that names no field of the identity shape the orbital resolves against: the declared [identity] entity (ORB_S_UNKNOWN_IDENTITY_FIELD), the orbital's own `expects entity [identity] { shape }` (ORB_S_EXPECTATION_FIELD_UNDECLARED), or the default shape; every shape carries the installed language's Viewer members (read from LINT_LANGUAGE_FACTS). A declared roster also re-checks the authored traits against the orbital's expects shape. Bodies inlined from a uses import (sourceBehavior) are skipped against an expectation. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint user-field-exists: 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-user-identity.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-user-identity [
   version: "1.0.0",
   inbound: ["cli-lint-user-identity"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-user-identity — the `orb lint user-identity <file>` command, the port of user_identity.rs (validate_user_identity). It lowers the file with program/read and reports a literal compared against a closed-vocabulary `@user.<field>` of the [identity] entity (or of the orbital's own `expects entity [identity] { shape }`) that is not a declared member, through =, ==, !=, !==, eq, neq and array/includes with a list, bare or field haystack, in every inline trait (ORB_S_ROLE_LITERAL_NOT_MEMBER, at the Rust trait path), a page nav role no role field of the [identity] entity declares (same code, at orbitals[i].pages[k].roles) (status 500, exit 1). Not ported: the `@user.<field>` existence checks (ORB_S_UNKNOWN_IDENTITY_FIELD, ORB_S_EXPECTATION_FIELD_UNDECLARED), which need the installed language's Viewer members, and the role literals of config-held role lists (check_config_role_lists), which need the compiler's role_list_sites dataflow. Clean answers `lint user-identity: 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-viewer-stranded.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-viewer-stranded [
   version: "1.0.0",
   inbound: ["cli-lint-viewer-stranded"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-viewer-stranded - the `orb lint viewer-stranded <file>` command, the port of ORB_CIRCUIT_VIEWER_STRANDED (circuit/closed_circuit.rs validate_viewer_stranded_for_owner). For each page whose content owner std-orb-lint-page-content-owner resolves to a channel or a sole writer, an arm of the owner that is a user-triggered affordance (an event some trait of the orbital fires by a control or an effect, emits or listens for, closed over listens routes; async-result events of fetch and persist and bus-excluded events are no affordance) and repaints a main slot with a body that offers no way on is ORB_CIRCUIT_VIEWER_STRANDED. A body offers a way on when it holds a content-body pattern (a pattern with an entity-kind prop), a pattern node whose event, event-ref, event-listen, callback or event-map prop (or the eventField of an event-list item) holds a live value (a binding, or a non-empty name the bus delivers), an @trait.X embed of a trait that is not inline in the orbital or whose own main bodies offer a way on (the least fixed point over the embed graph, so a cycle earns no credit), or an @entity.f or @config.k binding with no same-arm literal source (a set before the render-ui in the same arm, through let, do and if, or a tree-shaped config default), whose literal trees are read the same way. An arm that runs its own fetch or persist, a null body, an arm that leaves for a state with another producible arm, and a second arm of an event already reported are silent. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint viewer-stranded: 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-mcp-install.lolo

@@ -1,7 +1,7 @@
 app std-orb-mcp-install [
   version: "1.0.0",
   inbound: ["cli-mcp-install"],
-  exec: ["orb"],
+  exec: [exe, "orb"],
   env: ["PATH", "HOME"],
   fs: { cwd: "**": [read, write, create] },
   description: "std-orb-mcp-install — the `orb mcp install --client claude|cursor|vscode` command. It registers the `orb` MCP server in the directory the command runs in (claude: .mcp.json, cursor: .cursor/mcp.json, vscode: .vscode/mcp.json): the entry runs `npx -y @almadar/orb mcp` (the vscode entry also carries type stdio) under `mcpServers` (claude, cursor) or `servers` (vscode). Every other entry and key of an existing config is kept; a config that is not a JSON object, or a servers key that is not an object, is left unchanged and answered with its path (status 500, exit 1); the parent directory is created when missing. A missing or unknown --client, or any further word, answers the usage (status 400, exit 2). On success the answer is `Registered `orb mcp` in <path>`; the installed language is then checked through std-cli (`orb list --global`) and a failure adds a warning line naming `npx -y @almadar/orb update --global`. The file is written as compact JSON followed by a newline."

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

@@ -2,7 +2,7 @@ app std-orb-mcp [
   version: "1.0.0",
   env: ["ALMADAR_PERSONA_OWNS", "PATH"],
   inbound: ["cli-mcp"],
-  exec: ["orb"],
+  exec: [exe],
   stdio: [in, out],
   fs: { cwd: "**": [read, write], "/**": [read, write], "~/.orb/**": [read] },
   description: "std-orb-mcp — the `orb mcp [--program <file>]` command: the MCP server as a std program (spec/cli/mcp-server.lolo). The hook cli-mcp takes argv; `--program <file>` names the program whose inbound hooks are served as tools beside the language's. The server version is what `orb --version` answers (`orb X.Y.Z`), run from PATH (os/spawn takes a literal command, so the running binary's own path cannot be spawned). Stdin line framing is owned by std-stdio-lines; each line is acknowledged only after its tool answers, preserving serial requests, fragmented UTF-8 and the final unterminated line. Replies are compact JSON lines on stdout; EOF ends the command after every request is answered. Protocol: initialize, ping, tools/list, tools/call, prompts/list, prompts/get; a parse error is code -32700 with the text `parse error: invalid JSON` (the Rust server's serde wording is not reproduced), an unknown method -32601, an unknown prompt -32602, an unknown tool a tool result with isError. Tools served: validate, format (the text read from the file formatted by program/print { source }, comments kept; with `write: true` the file is rewritten with that text and the answer is still { source }), behaviors (with `scopes`: those registry folders cataloged; without: every installed package from behavior/packages cataloged one package at a time, vectors omitted, answering { behaviors, skipped: [{ package, error }] } where a package whose behaviors do not lower is reported and skipped; the host indexes a package whole, so the unit skipped is the package, not one behavior), describe_behavior, read_behavior ({ path, source } through behavior/source file: true), play, operators, patterns, evaluate (the expression in a one-transition program built with quasiquote, played through program/step with the request entity and payload). complete, reference and test run std-orb-complete, std-orb-reference and std-orb-test. Hook tools from --program are listed from program/inputs and called by program/dispatch with inbound; the guest-binding gap is recorded in the std ledger."
@@ -176,7 +176,7 @@ orbital OrbMcpOrbital {
     state versioning {
       INIT -> versioning
       MCP_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: MCP_SPAWNED, failure: MCP_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: MCP_SPAWNED, failure: MCP_START_FAILED } })
       MCP_START_FAILED -> starting
         (emit MCP_ANSWERED { status: 500, body: (str/concat "orb mcp: " (default @payload.error "")) })
       MCP_SPAWNED -> versioning

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

@@ -1,7 +1,7 @@
 app std-orb-supervise [
   version: "1.0.0",
   inbound: ["cli-supervise"],
-  exec: ["orb"],
+  exec: [exe],
   env: ["PATH", "HOME"],
   stdio: [out, err],
   fs: { cwd: "**": [read] },

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

@@ -2,7 +2,7 @@ app std-orb-update-notice [
   version: "1.0.0",
   inbound: ["cli-notice"],
   env: ["ORB_NO_UPDATE_CHECK", "CI", "PATH", "HOME"],
-  exec: ["orb"],
+  exec: [exe, "orb"],
   fs: { "~/.orb/**": [read, write, create], "~/.orb": [create], cwd: "orb.lock.json": [read] },
   net: { "registry.npmjs.org:443": [tcp], "*.npmjs.org:443": [tcp] },
   description: "std-orb-update-notice — the daily updates-available notice and the urgent auto-update (spec/cli/orb-update-notice.lolo; golden: orbital-cli update_notice.rs). The call's first argv word `record` (after orb update) stamps ~/.orb/.update-check.json as checked now with nothing available and no urgent rows and prints nothing. Any other call is quiet when ORB_NO_UPDATE_CHECK or CI is set, and silent when stderr is not a terminal; a quiet call on a terminal only reports, loudly on stderr, each failed urgent row the cache holds, and never scans or updates. Otherwise it reads the cache { checkedAt (seconds), available [[name, installed, newest, store]] (a three-word row is the global store), urgent [[store, status, text]] (status applied or failed) }: a cache under a day old with no failed urgent row answers its list, an older, absent or garbled one rescans, and a cache with a failed urgent row acts at once on those stores without waiting for the day. The scan covers the global store (each @almadar/ dependency of ~/.orb/package.json with its range and its installed version in ~/.orb/node_modules/<name>/package.json) and the working directory's orb-installed packages (each name and version pinned in ./orb.lock.json, any version above the pinned one counts): it asks std-npm-lookup for the versions, walks the stable ones (no prerelease) from the newest down until std-semver says one satisfies the range, and keeps the package when that version compares above the installed one; a package that is not installed, whose lookup is refused, whose range std-semver refuses, or that no stable version satisfies is skipped. The registry's per-version orbRelease block (severity, advisory, fixes) is read by the update itself, not here: after the scan the notice runs `orb update --urgent` (project store, when the lockfile pins packages) and `orb update --urgent --global` through std-cli with ORB_NO_UPDATE_CHECK set so the child never recurses, and records what each printed. Every stdout line of the child is an applied urgent update (recorded status applied and printed as `orb: applied urgent <line> (<store> store)`); a non-zero exit, or a child that could not run, records status failed with the child's stderr and prints `orb: URGENT UPDATE FAILED for the <store> packages: <why>` and that the vulnerable version is still installed, on stderr, so the installed version is kept and nothing is hidden. Normal updates keep the one stderr line `orb: updates available (<name> <from> → <to>, …); run `orb update --global`` (a project package says `in this project` and `orb update`). The cache is written (a failed write is ignored) with the urgent rows, and the answer carries the stderr lines or nothing."

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

@@ -2,7 +2,7 @@ app std-orb-validate [
   version: "1.0.0",
   inbound: ["cli-validate"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-validate — the `orb validate <file> [--json] [--deny-warnings] [--final] [--patterns <path>] [--services <path>]` command (spec/cli/orb-validate.lolo; port of orbital-cli commands/validate.rs validate_schema). The core checks are the host op `(program/validate null { report: true path final denyWarnings patterns services })`, which answers exactly the report `orb validate --json` printed: { success, valid, errors?, warnings?, stats? }. The path is the working directory joined to the file when relative. --json prints that report as 2-space pretty JSON (status 200, as Rust exited 0 for an invalid program). The text form prints `Validating schema: <file>` on stdout, then on errors `Schema validation errors:` and one `  ❌ [CODE] path: message @ line:col 💡 suggestion` line per error on stderr followed by `Error: Schema validation failed with N error(s)` (status 500); on warnings alone `Schema validation warnings:` and `  ⚠️  …` lines on stdout, and under --deny-warnings `Error: Schema validation failed: N warning(s) under --deny-warnings` on stderr (status 500). A file the host could not read (FILE_READ_ERROR) prints `Error: <reason>` on stderr (status 500). Under --final the host is never asked for the retired `final` check: the final-only rules of the composed std-orb-lint-engine (expectation-final, not-found, control-unhandled; their findings arrive in LINT_COLLECTED.final over the same lint input) join the policy findings in the same host call; without --final they are dropped. Policy lints (the std-orb-lint-engine orbital, composed here; it answers LINT_COLLECTED) merge into the report: an error-severity lint finding joins errors, a warning joins warnings. Usage error: status 400 (exit 2). Known differences from the Rust bytes: a finding the host reports without a line prints no ` @ line:col`; lint findings carry no source position."
 ]

package/behaviors/lolo/dev/atoms/std-launchpad-updates.lolo

@@ -1,6 +1,6 @@
 app std-launchpad-updates [
   version: "1.0.0",
-  exec: ["orb"],
+  exec: [exe, "orb"],
   env: ["PATH", "HOME"],
   sys: [self-signal],
   description: "std-launchpad-updates — the launchpad's view of the update record orb's update notice keeps in ~/.orb/.update-check.json ({ checkedAt, available [[name, installed, newest, store]], urgent [[store, applied|failed, text]] }) and the button that runs the update. UPDATES_LOAD reads the record: the record is read through std-orb-update-record, its one owner: a file that does not exist is no update (UPDATES_LOADED with nothing), a file that is not a record in that shape (another writer's, garbled) answers UPDATES_UNCHECKED, any other read failure answers UPDATES_FAILED { error }, and a good record answers UPDATES_LOADED { available, urgent } (urgent is empty when the record has none). The banner draws UPDATES_UNCHECKED as an info alert titled No update check yet, saying the record is not readable and the next due update check writes it again, never as a failed update. UPDATES_RUN { store } runs `orb update --global` for the global store and `orb update` for any other store through std-cli (the orb on PATH) and, when the run ends, answers UPDATES_RAN { store } on exit 0 or UPDATES_RUN_FAILED { store, error } (the child's stderr, or its exit code, or why orb could not start), then reads the record again either way; The banner (UpdatesBanner) reads the record at INIT and on UPDATES_REFRESH and draws, as core patterns, an info alert with an Update button per store that has available updates, a success alert per applied urgent row (advisory text and the restart text), an error alert per failed urgent row (the vulnerable version is still installed) with a Retry button, a success alert after a finished run that says the launchpad restarts if a service manager runs it, each applied alert with a Restart button (UPDATES_RESTART_PRESSED, listened as UPDATES_RESTART, the store reads os/pid and sends os/kill TERM to its own pid, so the process exits and its service manager starts it again on the new orb), and an error alert for a failed run or a failed read; no record draws nothing. A run asked while another is in flight answers UPDATES_RUN_FAILED at once.",

package/behaviors/lolo/dev/atoms/std-orb-stats.lolo

@@ -1,6 +1,6 @@
 app std-orb-stats [
   version: "1.0.0",
-  exec: ["orb", "ps"],
+  exec: [exe, "orb", "ps"],
   env: ["PATH", "HOME"],
   description: "std-orb-stats — what the orb running this program reports about itself. ORB_STATS_ASK reads the kernel's counters with program/inputs { stats: true } (registeredSchemas, registeredTraits, activeInstances, cachedEntities) and answers ORB_KERNEL_READ { registeredSchemas, registeredTraits, activeInstances, cachedEntities }; every ask also reads the uptime of the orb process: os/pid gives the host process id and `ps -o etime= -p <pid>` runs through std-cli (the ps on PATH), its [[dd-]hh:]mm:ss answer is parsed to milliseconds and answered as ORB_UPTIME_READ { uptimeMs }, so the figure is the process's, not the session's or the first ask's; the first ask also runs `orb --version` through std-cli (the orb on PATH) and answers ORB_VERSION_READ { version } with the output trimmed; the version is read once per mount, and every later ask answers ORB_VERSION_READ again with it, so a client that joined later still gets it. A kernel read that the host refuses, a version run that exits non-zero or cannot start, a pid the host cannot give, a ps run that exits non-zero or cannot start, or an elapsed time that is not that format, answers ORB_STATS_FAILED { stat, code, error } (stat kernel, version or process-uptime) and the other stats are still answered. Subject-agnostic: it knows nothing of who asks.",
   egress: []

package/behaviors/lolo/dev/organisms/std-launchpad.lolo

@@ -3,7 +3,7 @@ app std-launchpad [
   theme: "linear-clean-light",
   locales: [en, ar, sl],
   themes: ["linear-clean-dark", "almadar-light", "almadar-dark", "minimalist-light", "minimalist-dark", "notion-editorial-light", "swiss-light", "bloomberg-dense-dark", "terminal-dark", "game-sci-fi-dark"],
-  exec: ["orb", "ps", "aws", "bq", "gcloud", "gh", "ssh", "kill"],
+  exec: [exe, "orb", "ps", "aws", "bq", "gcloud", "gh", "ssh", "kill"],
   kernel: { "guest": [spawn] },
   env: ["PATH", "HOME", "FIREBASE_AUTH_EMULATOR_HOST", "ALMADAR_PERSONA_OWNS", "ALMADAR_VECTORS_DIR", "EMBEDDING_PROVIDER", "EMBEDDING_API_KEY", "OPENAI_API_KEY", "OPEN_ROUTER_API_KEY", "EMBEDDING_MODEL", "LMSTUDIO_EMBEDDING_MODEL"],
   sys: [memory, cpu, self-signal],