@shardflux/cli 0.14.4 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## 0.15.0
+
+- The onboarding activity report includes the conversation's turn state for Claude and Codex, including while its VM is suspended.
+
+- `shard setup --inspect`: a new Codex remote device reads as connecting while it finishes starting, instead of offering Retry. The live activity report lists only the ports the agent opened, not the computer's own services.
+
+- The terms: `shard signup`, `shard auth register` and `shard auth login --codex` (which can create an account) need the agreement to the Terms of Service and Privacy Policy before they send anything: `--accept-terms`, `SHARDFLUX_ACCEPT_TERMS=1`, or "Continue? [Y/n]" on a terminal. Without it they stop with `terms_not_accepted` (exit 2; `details`: `terms_url`, `privacy_url`, `flag`). The account records the agreement. Signing in shows the same line, and `--json` sign-in and sign-up outputs carry `terms_url` and `privacy_url`.
+
+- `shard ./` and `shard agents new` accept `--image <file|->` with an initial prompt: attach up to five PNG, JPEG, GIF or WebP images (10 MiB each) to the first message. Images are validated before the VM is created, written privately into the conversation VM under `/home/user/.shardflux/attachments/`, and named in the first message, so Claude Code attaches them natively and Codex opens them with its image viewer. `--image -` reads one image, or PNG images back to back, from standard input, so the menu bar's screen captures never touch the Mac's disk.
+
+- `shard auth login --browser` signs in on the web: it opens the sign-in page with a code (`--no-open` prints the link), you sign in or create your account there, check the code and approve, and the session is saved as with a password. `--client-name` names the computer on the page. It prints the terms notice (Terms of Service, Privacy Policy) before the browser opens. `--json` prints NDJSON events for apps: `open` (link, code, `expires_in`, `terms_url`, `privacy_url`), then `signed_in` (email) or `error` (`access_denied`, `expired_token`, ...; exit 4). On a terminal, `shard auth login` without `--email` or `--codex`, and `shard signup` without a Codex login or `--email`, use the browser.
+
+- `shard acp` signs in from the editor: it offers T3 Code and other ACP clients a "Sign in to Shardflux" method that runs in the editor's own terminal (`shard acp --login`). One step creates or signs in to the account with this Mac's Codex login (else an email), makes the API key, copies the Codex login and connects Claude Code. Signed out, `shard acp` answers ACP `auth_required`, so the editor offers it.
+
+- T3 Code's provider probe and its post-sign-in check open no VM, and a conversation started from the probe's first model choice (`Codex · Default`, `Claude Code · Default`) opens on that app's own default model.
+
+- `shard agents open` on a Claude conversation this computer just started returns its Remote Control URL as soon as Claude publishes it, waiting up to 30 s (or `--wake-timeout`, if shorter) while Claude registers.
+
+- Resume an ACP conversation after its journal is reconstructed on the same VM: reset the old journal cursor when the native supervisor changes, while preserving the native session id.
+
+- Keep legacy workspace opens, explicit terminal/T3 launches and template-copy launches on their existing paths; prepare local Git before Codex Cloud enrollment.
+
+- Claude conversations wake from claude.ai or the Claude app at any time. `--reachable` (`agent_reachable_seconds` on the wire) is deprecated and ignored; the option remains accepted and is hidden from help.
+
+- Idle Codex Cloud MCP sessions no longer keep the VM awake. Stdio servers retain their process and memory in the VM behind request-scoped HTTP, so normal adaptive suspend and wake preserve their state.
+- New Codex Cloud threads receive the VM’s configured MCP servers and Shardflux computer, conversation and credential tools through the native remote executor. No separate connector setup is required.
+- New Codex conversations from `shard ./` and `shard agents new --app codex --path <dir>` open genuine Codex Cloud threads under one account executor. `agents open` reopens Cloud history without waking its VM. Setup copies the existing Codex login and registers the billed account executor; `agents codex status|enable|disable` manages it. Existing local conversations retain their original route.
+
+- Add `credentials approve --scope ask|project|machine` and scoped `credentials forget`. Share machine vault choices across projects in the current account/profile, with project choices taking precedence. Remember only the requested fields at the selected scope.
+
+- Simplify the terminal command center to one-line live conversations, collapsed done sessions, and a contextual actions menu. New conversation asks for a task and project, then starts Claude or Codex with that first message. Existing open, target, log, workspace and Git actions remain available.
+
+- Give the menu bar structured device approval details (exact argv, canonical path, file direction and port mapping) while retaining the summary for older clients. Outside-conversation requests still require one-time approval.
+
+- Fresh conversations accept `--prompt` or `--prompt-file <path|->` as their first native user-authored message. Validate before allocation, deliver through acknowledged native terminal input, and preserve the created workspace key on a delivery failure. Prepare fresh Codex worktrees to avoid startup trust/update dialogs and use a usable terminal type for detached launchers.
+- Emit device approval resolution events so the menu removes completed requests immediately.
+
+- `agents new --path` starts a fresh conversation; named and `--like` agent flows keep their existing behavior.
+- `agents open --in auto --json` returns the remembered desktop target or the agent app destination (`url` or `app_bundle_id`) for launchers such as menu bar 0.3.0.
+
+- First run: `shard setup --inspect [--json] [--apps claude,codex] [--connect]` checks every connection live and
+  reports it: the Shardflux account, Claude (Claude itself accepts the account login) and Codex (the login is copied and
+  the account's Codex remote device is connected), for the apps you pick, or the ones found on this Mac. `--connect`
+  also copies this Mac's Codex login and enables the Codex remote device; `--retry-codex` starts a remote device that
+  failed or is stuck starting again, once (as `agents codex enable` now does). The Codex row reads its remote device as
+  connecting, connected, failed (its VM failed) or stuck (starting for more than five minutes). The apps checked are
+  `--apps`, else your saved pick, else the ones found on this Mac, including in their install folders (`~/.local/bin`
+  and others) when the PATH is minimal. Ready means signed in with at least one
+  agent app connected. When T3 Code is installed the report adds an optional `t3` entry: an ACP-capable build has
+  Shardflux as a provider (connected once signed in; its provider's Sign in finishes it otherwise), stable 0.0.45 is
+  set up per project over SSH (`agents new --in t3 --path <project>`) and names the environment to add. The report
+  lists the steps (sign in, connect, try it once on Daylight, your own project). `--prepare-sample` copies the Daylight sample app into a new local Git project,
+  "Daylight (sample)"; `--activity --workspace <key|conv_id>` lists a running VM's current commands and when they
+  started, listening ports, packages installed with sudo since it was created, its desktop's size and browser window,
+  and what changed in its repositories, without waking it.
+- `agents new --computer` (and `shard <path> --computer`) gives the new conversation a desktop with a browser its agent
+  drives, for Claude and Codex conversations.
+- A long first prompt (`--prompt`, `--prompt-file`) is submitted even when its start scrolls out of the agent's input box.
+- `agents open --in web` (and `--in auto` for Claude) waits up to 20 seconds for a new conversation's Remote Control link
+  instead of failing in the first seconds after the conversation starts.
+
+## 0.14.5
+
+- An agent terminal no longer keeps its workspace awake. `shard ./` and `shard agents open` attach passively: while the agent waits, its workspace parks and suspends under the open terminal. Once it has gone to sleep, the terminal shows `asleep. Type to wake it.`, and your next keystroke wakes it and reaches the agent. A dropped connection reattaches without waking the workspace.
+- Requires `@shardflux/sdk` 0.20.0: `shard ws tunnel` and the device bridge carry a reset on either side as a reset (`ECONNRESET`), never as a clean end of stream.
+
 ## 0.14.4
 
 - `shard <path> --codex` and `--claude` choose the agent like `shard <path> codex` and `claude`. An unknown option or app on `shard <path>` names the right form, e.g. `shard ./ codex`.

package/README.md

@@ -24,6 +24,14 @@ For usage, account, billing, or private support, email [shardflux@heliosone.fi](
 Report vulnerabilities through [private security reporting](https://github.com/shardfluxdev/community/security/advisories/new).
 See the [support guide](https://github.com/shardfluxdev/community/blob/main/SUPPORT.md) for all reporting options.
 
+## Command center (0.15.0+)
+
+Run `shard` in a terminal to see live conversations. Press **Enter** to open the selected one, **/** to search,
+**D** to expand or collapse finished conversations, and **?** for targets, logs, fork, park and Git actions.
+Press **n** to start a conversation: describe the task, confirm a local project folder, then choose Claude or Codex.
+Both the task and project are required, and the task becomes the first user-authored message. **Esc** cancels;
+**q** returns to your shell. The command center calls the same `shard agents new --path ... --prompt ...` path.
+
 ## Reverse tunnels (0.11.0+)
 
 Run a foreground TCP tunnel from a workspace to a service on this machine:
@@ -33,7 +41,7 @@ shard ws tunnel customer-42/main --remote 8081 --to localhost:8081
 ```
 
 Commands in the workspace can then call `http://127.0.0.1:8081`. The target is dialed on the machine running
-`shard`. Ctrl-C closes the sockets and guest process. `--bind 0.0.0.0` selects all guest interfaces; loopback is the
+`shard`. Half-close and resets pass through: a reset on either side reaches the other as `ECONNRESET` (0.14.5+). Ctrl-C closes the sockets and guest process. `--bind 0.0.0.0` selects all guest interfaces; loopback is the
 default. An open tunnel keeps the workspace awake, and persistent workspaces preserve it across explicit suspend/resume.
 
 The tunnel selects a streaming transport automatically when `pty` permission is granted. Choose `transport: 'pty'` or `transport: 'exec'` in the SDK, or `--transport pty|exec` in the CLI, to select it explicitly. The handle reports `transport`.
@@ -67,7 +75,10 @@ time `shard` runs, with launch at login enabled; `shard menubar stop` turns it o
 
 T3 Code uses one **Shardflux** provider; choose a Claude Code or Codex model to start that agent in the cloud.
 Model choices come from your cloud agent's session and use the same coding tools and settings as its terminal.
-The provider is registered automatically when T3 Code is installed. Use a T3 build that supports ACP providers.
+The provider is registered automatically when T3 Code is installed. Choose **Sign in** on its card in T3's provider
+settings: T3 runs `shard acp --login` in its own terminal, which creates or signs in to your account (with this Mac's
+Codex login, or your email) and connects Claude Code and Codex, skipping every step that is already done (0.15.0+).
+With T3 Code 0.0.45, `shard agents new --in t3` adds the project as an SSH environment instead.
 
 Git fetch and push use the coding guest’s platform transport when available, preserving Git’s binary packets (0.14.0+). Older guests retain their existing transport.
 
@@ -79,7 +90,7 @@ shard conversations try <conversation>
 
 Your branch opens in `.shard/worktrees/<name>`, syncs both ways, and its dev servers appear at localhost.
 Ctrl-C stops local sync. Your main checkout stays available for your own work.
-Device tools ask Allow once or Always for this project on your Mac before preparing the conversation’s local worktree. Live transcripts stay in
+Device tools ask for approval on your Mac before preparing the conversation’s local worktree. With CLI 0.15.0 and menu bar 0.3.0, Review shows the exact command, file direction, paths or port mapping; access outside the conversation folder only offers Allow once. Live transcripts stay in
 `~/.config/shardflux/conversations/`; ended sessions enter Claude Code’s or Codex’s native history. Transcript files up to 64 MiB are supported (0.14.0+).
 From 0.14.3, transcript copying runs independently of device approvals. Unknown entries are skipped, and failed copies retry with backoff; diagnostics name the conversation and affected entry.
 
@@ -136,14 +147,19 @@ npm test 2>&1 | tail -n 60 | shard feedback --category bug --workspace acme/demo
 `shard` is built to be driven by an agent: no browser, no prompts when standard input is not a
 terminal, `--json` on every command, secrets only on standard input, and documented exit codes.
 
-1. **Account (0.9.0+):** `shard signup --json`. With the Codex CLI signed in with ChatGPT on the
+1. **Account (0.9.0+):** show your person the [Terms of Service](https://shardflux.dev/terms) and the
+   [Privacy Policy](https://shardflux.dev/privacy); once they agree, `shard signup --accept-terms --json` (0.15.0+:
+   without `--accept-terms` or a terminal to ask on, it stops before sending anything with `terms_not_accepted`, exit 2,
+   and the two links in `details`). With the Codex CLI signed in with ChatGPT on the
    machine it signs up (or signs in) verified by that login; otherwise pass `--email <email>` and the
    account works at once on the Free plan. It then runs `shard setup`: an organization, a project and
    an API key with every workspace tool, saved in the credentials file. With two-factor authentication
    it exits 4 with `mfa_required`: ask the person for the code, then `shard auth mfa --code <code>`.
 2. **Verify the email** (an `--email` signup, to start the trial): `shard verify --json` emails a
    6-digit code; ask the person for it, then `shard verify <code>`. Nothing is signed out.
-3. **Set up again any time:** `shard setup --json` is idempotent.
+3. **Set up again any time:** `shard setup --json` is idempotent. `shard setup --inspect --json --apps claude,codex`
+   (0.15.0+) checks every connection live (your account, Claude, Codex) and says what to do for any that is not ready;
+   `--connect` also finishes the Codex connection.
 4. **Work:** `shard exec <key> --template default -- <cmd>` creates the workspace on first use and runs the command
    (0.10.0+); later commands reuse it. `shard ws open <key> --template <slug> --json`, `shard files ...` use the saved
    key too.
@@ -164,10 +180,11 @@ What a person does: entering a card in Stripe Checkout, the authenticator app's
 ## Accounts and sign-in (0.5.0+)
 
 ```sh
-shard signup [--email you@example.com] [--name "Ada Lovelace"] [--no-codex] [--no-setup]   # 0.9.0+
+shard signup [--email you@example.com] [--name "Ada Lovelace"] [--no-codex] [--no-setup] [--accept-terms]   # 0.9.0+
 shard verify [<code>]                                  # 0.9.0+: emails a 6-digit code, then confirms it
-shard auth login --codex                               # 0.9.0+: sign in with the Codex login on this machine
-printf '%s\n' "$PASSWORD" | shard auth register --email you@example.com [--name "Ada Lovelace"]
+shard auth login --browser [--no-open]                 # 0.15.0+: approve this computer on the sign-in page
+shard auth login --codex [--accept-terms]              # 0.9.0+: sign in with the Codex login on this machine
+printf '%s\n' "$PASSWORD" | shard auth register --email you@example.com [--name "Ada Lovelace"] [--accept-terms]
 shard auth verify-email '<link from the email>'        # or just the token in it
 shard auth resend-verification                         # signed in, email not verified yet
 printf '%s\n' "$PASSWORD" | shard auth login --email you@example.com [--code 123456 | --recovery-code X]
@@ -193,6 +210,24 @@ shard auth totp recovery-codes
   already uses that ChatGPT identity or email is signed in instead. Without a Codex login, `--email`
   creates an account that works at once on the Free plan; `shard verify` starts the trial.
   `--no-codex` uses `--email` even when Codex is signed in; `--no-setup` skips `shard setup`.
+- **`shard auth login --browser`** (0.15.0+) opens the sign-in page (`https://app.shardflux.dev/cli?code=XXXX-XXXX`)
+  in the default browser and prints the link and the code. Sign in or create your account on the page, check that it
+  shows the same code, and approve: `shard` saves the session like a password sign-in, and two-factor accounts use
+  their code on the page. `--no-open` only prints the link; `--client-name` sets the name the page shows (default
+  `shard CLI on <hostname>`). The code expires after 10 minutes. On a terminal, `shard auth login` without `--email`
+  or `--codex`, and `shard signup` without a Codex login or `--email`, sign in this way. With `--json` it prints one
+  JSON object per line: `{"event":"open","verification_uri_complete":"…","user_code":"ABCD-EFGH","expires_in":600,
+  "terms_url":"https://shardflux.dev/terms","privacy_url":"https://shardflux.dev/privacy"}`, then
+  `{"event":"signed_in","email":"…"}`, or `{"event":"error","code":"access_denied","message":"…"}` (also
+  `expired_token`, exit 4). Before the browser opens it prints the terms notice: by continuing you agree to the
+  Terms of Service and acknowledge the Privacy Policy.
+- **The terms (0.15.0+):** the commands that can create an account (`signup`, `auth register`,
+  `auth login --codex`) need your agreement to the [Terms of Service](https://shardflux.dev/terms) and the
+  [Privacy Policy](https://shardflux.dev/privacy): `--accept-terms` (or `SHARDFLUX_ACCEPT_TERMS=1`), or "Continue?
+  [Y/n]" on a terminal. Without either they stop before sending anything: `terms_not_accepted`, exit 2, with
+  `terms_url`, `privacy_url` and `flag` in `details`. The account records the agreement. Signing in only shows the
+  line (`terms_url` and `privacy_url` in `--json`); so does `auth login --browser`, which needs no flag: an account
+  created on the sign-in page agrees there.
 - **Passwords never come from arguments** (`--password` is refused). On a terminal `shard` asks without
   echo (a new password twice); otherwise it reads standard input, one line per secret: `auth password
   change` reads the current password, then the new one. Emailed links and tokens are single-use
@@ -980,7 +1015,7 @@ printf %s "$NEW_KEY" | shard secrets rotate OPENAI_API_KEY
   - Account commands (0.5.0+) print the API's objects too: lists are `{data, next_cursor}` (with
     `default_organization_id`, `default_project_id` or `saved_api_key_id` where a default applies);
     `auth login`/`auth mfa` print `{status, user, session: {expires_at, credentials_file}, organizations,
-    next}` (never the token); `auth status` prints `{api_url, credentials_file, session, api_key, defaults}`;
+    next}` (never the token; `auth login --browser` prints NDJSON events instead, see above); `auth status` prints `{api_url, credentials_file, session, api_key, defaults}`;
     `setup` prints `{organization, project, api_key: {id, key_id, name, project_id, tool_permissions},
     created: {organization, project, api_key}, credentials_file, next}`; `api-keys create` prints
     `{api_key, secret, saved: false}` (or `{api_key, saved: true, credentials_file}` with `--save`);
@@ -1009,7 +1044,7 @@ printf %s "$NEW_KEY" | shard secrets rotate OPENAI_API_KEY
 | 1 | error: an API refusal such as `conflict`, `quota_exceeded` or `workspace_not_running`, or a network or protocol failure |
 | 2 | usage error: bad arguments, or input the API rejected as `validation_failed` |
 | 3 | not found: workspace, operation or route |
-| 4 | authentication or authorization: missing, malformed, revoked or insufficient key or session; `step_up_required` (run `shard auth step-up`), `mfa_required` (a sign-in waiting for its code), `email_unverified`, `invalid_credentials` |
+| 4 | authentication or authorization: missing, malformed, revoked or insufficient key or session; `step_up_required` (run `shard auth step-up`), `mfa_required` (a sign-in waiting for its code), `email_unverified`, `invalid_credentials`; `access_denied` or `expired_token` from `auth login --browser` (0.15.0+) |
 | 5 | timeout: waiting gave up (`--timeout`, or `--wake-timeout` while waking a workspace); the operation continues server side (`shard operations wait <id>`), up to a queued start's 15-minute deadline. `executions get` (0.5.0+): the execution is still queued or running. `ws exec-read` (0.8.0+): the background command still runs. `billing upgrade --wait` (0.5.0+): nobody paid in time (the checkout stays open) |
 | 6 | the awaited operation ended `failed` or `canceled` (also a resume or open that failed while waking a workspace). `retryable=true` in the error means a retry can succeed (`capacity_unavailable`). Also a file-first execution that ended `failed` or `lost` (0.5.0+): nothing was published. `exec` (0.5.1+): the command could not start (`exec_failed_to_start`). `billing upgrade --wait` (0.5.0+): the checkout expired or was canceled (`checkout_ended`) |
 | 130 | interrupted (Ctrl-C). Waits stop at once, and exec sends a cancel to the session. A file-first execution runs to completion, and the error names the `shard executions get` command for its result. |
@@ -1148,7 +1183,7 @@ Template services accept `initialized_cpu` with `compatibility`, `reset`, and `t
 
 ### Waiting agent reachability (0.13.2+)
 
-Set `--reachable 30m` when opening a workspace to choose how long waiting agents stay reachable through connections they opened. See [reachability settings](https://docs.shardflux.dev/limits#cloud-agent-reachability). Incoming replies wake the parked workspace, which answers them and parks again. These wakes count as parked time; agent work counts as awake time.
+A message from claude.ai or the Claude app wakes a waiting Claude conversation at any time. Reply-traffic wakes count as parked time; agent work counts as awake time. The reachability duration is deprecated and ignored (0.15.0+).
 
 
 ## Cloud agents (0.13.2+)
@@ -1180,6 +1215,8 @@ Imported secrets: stored encrypted with AWS KMS; only this project's workspaces
 Vault fills: sent end to end from your vault to the workspace; Shardflux only relays encrypted bytes.
 Remembered credentials: stored encrypted with AWS KMS and filled straight into the page; agents never see it, and every use is logged.
 
+CLI 0.15.0 adds `credentials approve <request> --from keychain --item <name> --scope ask|project|machine`. The default still asks each time; `--always` retains its project-only behavior. Machine permission is shared across projects in the current account/profile, with project choices taking precedence. Add `--remember` to save only requested fields for unattended sign-in: `ask` saves for the conversation, `project` for the project template, and `machine` for the machine template. Remove a saved copy with `credentials forget <workspace> <site> --scope conversation|project|machine`. Without `--scope`, remember/forget retain the legacy project storage. Conversation and machine copies require the scoped-credentials API.
+
 [Start a cloud agent](https://docs.shardflux.dev/guides/cloud-agents) ·
 [Machine and template](https://docs.shardflux.dev/guides/machine-and-template) ·
 [Credentials](https://docs.shardflux.dev/guides/credentials)
@@ -1208,3 +1245,28 @@ Open that project connection to start conversations and return to their saved th
 Conversation JSON includes `join_mode` and the worktree used by reviewers and workers.
 
 `shard conversations resume <id>` continues a saved conversation in a fresh VM under the same identity (0.14.0+). `shard ./ --resume` uses this same path. `shard conversations reader <project-id>` opens a small read-only workspace for saved branches and transcripts; the Mac transcript mirror opens it automatically when no project VM is live. Adaptive idle reclaims the reader.
+
+### Menu bar conversation shortcut (0.15.0+)
+
+The macOS menu bar's **New conversation** action (menu bar 0.3.0+) opens the same launcher as **Option-Shift-Space**. It requires a task and project, remembers Claude/Codex, and invokes the commands below. Configure the hotkey in the macOS Settings window (⌘,), with conflict detection and a fallback.
+
+```sh
+shard agents new --app claude --path ./ --prompt "Review the billing changes" --json
+shard agents new --app codex --path ./ --prompt-file task.txt --json
+cat task.txt | shard agents new --app codex --path ./ --prompt-file - --json
+shard agents new --app claude --path ./ --prompt "What is wrong on this page?" --image page.png --json
+```
+
+`--prompt` or `--prompt-file` submits one initial user-authored message to the native agent. Codex Cloud accepts it into the durable conversation inbox with one idempotency key; `initial_prompt.submitted` confirms that acceptance, not a completed provider turn. Text is limited to 256 KiB and may include file, branch and link context. These options apply to fresh conversations and cannot be combined with resume or named/like legacy agent flows. Omit them to start interactively as before. JSON includes `initial_prompt.submitted: true` after native input is accepted. If delivery cannot be confirmed, `initial_prompt_failed` includes `details.workspace_key` and `details.submitted`; open that conversation before creating another.
+
+`--image <file|->` (0.15.0+, repeatable) attaches up to five PNG, JPEG, GIF or WebP images of up to 10 MiB each to that first message. They are written into the conversation VM under `/home/user/.shardflux/attachments/` and named in the message: Claude Code attaches them as images and Codex opens them with its image viewer. `--image -` reads one image, or PNG images back to back, from standard input; use a file for `--prompt-file` when images come from standard input.
+
+Use `shard agents open <workspace> --in auto --json` to resolve the remembered app destination. The result includes a `url` or `app_bundle_id` when that app route is available; the caller opens it. Explicit `--in terminal` retains terminal attachment. The menu uses this resolver for new and existing conversations, without provider URLs in Swift.
+
+## Codex Cloud (0.15.0+, unreleased)
+
+New Codex conversations use `shard agents new --app codex --path <directory>` or `shard ./ codex`. Each gets a fresh conversation VM and a genuine Codex Cloud thread. `shard agents open <conversation-id>` opens the existing thread without waking its VM. These paths create no SSH device entries and need no pairing.
+
+`shard setup` uses your existing Codex ChatGPT login to register one executor for the account. Its small connector workspace stays resident and is billed as ordinary workspace memory/CPU usage, including while conversations wait. Use `--no-codex` to skip setup, `shard agents codex status` to inspect it, or `shard agents codex disable` to remove the executor and release its residency. Conversation VMs wake for tools and follow the normal adaptive idle policy afterwards.
+
+Explicit `agents new --in terminal`, `--in t3`, and `--like` launches keep their existing VM routes. Local Git is prepared and validated before Cloud enrollment. This branch's Cloud feature is awaiting release. Existing local-mode conversations keep their original route. Cloud uses OpenAI's model/configuration capabilities; local app-server plugins and settings are not automatically transferred.

package/dist/account-args.js

@@ -4,6 +4,13 @@ const ORG = {
 const PROJECT = {
     project: { type: 'string', value: '<project>', description: 'Project: id or slug. Default: the saved one (shard projects use), else the organization’s only project.' },
 };
+/** Commands that can create an account (0.15.0+): the agreement to the terms, without a prompt. */
+const ACCEPT_TERMS = {
+    'accept-terms': {
+        type: 'boolean',
+        description: 'Agree to the Terms of Service (https://shardflux.dev/terms) and acknowledge the Privacy Policy (https://shardflux.dev/privacy) without the "Continue? [Y/n]" prompt (0.15.0+; also SHARDFLUX_ACCEPT_TERMS=1). Without a terminal, creating an account needs it: otherwise the command stops before it sends anything (terms_not_accepted, exit 2).',
+    },
+};
 const SECOND_FACTOR = {
     code: { type: 'string', value: '<totp>', description: 'Current 6-digit code of your authenticator app (two-factor accounts).' },
     'recovery-code': { type: 'string', value: '<code>', description: 'A one-time recovery code instead of --code.' },
@@ -52,9 +59,10 @@ export const ACCOUNT_COMMANDS = [
             codex: { type: 'boolean', description: 'Use the Codex login on this machine (default; --no-codex signs up with --email).' },
             setup: { type: 'boolean', description: 'Run shard setup afterwards (default; --no-setup skips it).' },
             tool: { type: 'string', multiple: true, value: '<tool>', description: 'Workspace tool the saved API key may use (repeatable; exec, files, pty, process, git, browser). Default: all.' },
+            ...ACCEPT_TERMS,
             ...SECOND_FACTOR,
         },
-        examples: ['shard signup', 'shard signup --email you@example.com', 'shard signup --no-codex --email you@example.com --name "Ada Lovelace"'],
+        examples: ['shard signup', 'shard signup --accept-terms --json', 'shard signup --email you@example.com', 'shard signup --no-codex --email you@example.com --name "Ada Lovelace"'],
     },
     {
         path: ['verify'],
@@ -73,6 +81,7 @@ export const ACCOUNT_COMMANDS = [
         options: {
             email: { type: 'string', value: '<email>', description: 'Your email address (required).' },
             name: { type: 'string', value: '<display name>', description: 'Your name as others see it (default: none; setup names the organization after it).' },
+            ...ACCEPT_TERMS,
         },
         examples: [`printf '%s\\n' "$PASSWORD" | shard auth register --email you@example.com --name "Ada Lovelace"`, 'shard auth register --email you@example.com   # prompts for the password'],
     },
@@ -87,15 +96,19 @@ export const ACCOUNT_COMMANDS = [
     { path: ['auth', 'resend-verification'], summary: 'Email a new verification link (signed in, email not verified yet)', positionals: [], options: {} },
     {
         path: ['auth', 'login'],
-        summary: 'Sign in: saves a session for this API in the credentials file (the password is read from standard input or a prompt)',
-        description: 'Two-factor accounts: pass --code (or --recovery-code), or type the code at the prompt; without either the pending sign-in is saved and "shard auth mfa --code <code>" completes it within 10 minutes (exit 4 until then). Prints who you are, your organizations and the next step. A session lasts 30 days of use (90 at most). SHARDFLUX_SESSION_TOKEN, when set, is used instead of the saved session.',
+        summary: 'Sign in: saves a session for this API in the credentials file (in the browser, or with a password from standard input or a prompt)',
+        description: '--browser (0.15.0+) opens the sign-in page with a code: sign in or create your account there, check that the page shows the same code, and approve; the session is saved here (the page link is printed too, and --no-open only prints it). On a terminal, "shard auth login" without --email or --codex signs in with the browser. --json prints one JSON object per line: {"event":"open",...} with the link and the code, then {"event":"signed_in","email":...} or {"event":"error","code":...,"message":...}. With a password, two-factor accounts pass --code (or --recovery-code), or type the code at the prompt; without either the pending sign-in is saved and "shard auth mfa --code <code>" completes it within 10 minutes (exit 4 until then). Prints who you are, your organizations and the next step. A session lasts 30 days of use (90 at most). SHARDFLUX_SESSION_TOKEN, when set, is used instead of the saved session.',
         positionals: [],
         options: {
-            email: { type: 'string', value: '<email>', description: 'Your email address (required without --codex).' },
-            codex: { type: 'boolean', description: 'Sign in with the Codex login on this machine instead of a password (0.9.0+; creates the account when there is none).' },
+            browser: { type: 'boolean', description: 'Sign in in the browser: open the sign-in page, approve this computer there (0.15.0+). An account created there agrees to the terms on the sign-up page, so --browser needs no --accept-terms.' },
+            open: { type: 'boolean', description: 'With --browser: open the page in the default browser (default; --no-open only prints the link).' },
+            'client-name': { type: 'string', value: '<name>', description: 'With --browser: the name the sign-in page shows for this computer (default "shard CLI on <hostname>").' },
+            email: { type: 'string', value: '<email>', description: 'Your email address, to sign in with a password.' },
+            codex: { type: 'boolean', description: 'Sign in with the Codex login on this machine instead of a password (0.9.0+; creates the account when there is none, so it needs --accept-terms like shard signup).' },
+            ...ACCEPT_TERMS,
             ...SECOND_FACTOR,
         },
-        examples: [`printf '%s\\n' "$PASSWORD" | shard auth login --email you@example.com`, `printf '%s\\n' "$PASSWORD" | shard auth login --email you@example.com --code 123456`, 'shard auth login --codex'],
+        examples: ['shard auth login --browser', 'shard auth login --browser --no-open --json', `printf '%s\\n' "$PASSWORD" | shard auth login --email you@example.com`, `printf '%s\\n' "$PASSWORD" | shard auth login --email you@example.com --code 123456`, 'shard auth login --codex'],
     },
     {
         path: ['auth', 'mfa'],
@@ -187,13 +200,21 @@ export const ACCOUNT_COMMANDS = [
         options: {
             ...ORG,
             ...PROJECT,
+            'prepare-sample': { type: 'boolean', description: 'Copy the Daylight sample app into a new local Git project, "Daylight (sample)", for the first-run demo; prints its path.' },
+            activity: { type: 'boolean', description: 'With --inspect: the current commands, listening ports, sudo installs and browser window of --workspace, without waking it.' },
+            workspace: { type: 'string', value: '<key|conv_id>', description: 'The workspace or conversation to inspect for live onboarding activity.' },
+            inspect: { type: 'boolean', description: 'Report the onboarding steps and verify every connection live (account, Claude, Codex) without changing anything.' },
+            apps: { type: 'string', multiple: true, value: '<claude,codex>', description: 'The apps to verify (default: the ones found on this Mac). Repeatable or comma separated.' },
+            connect: { type: 'boolean', description: 'With --inspect: also copy this Mac’s Codex login and enable the account’s Codex remote device when Codex is picked.' },
+            'retry-codex': { type: 'boolean', description: 'With --inspect --connect: start a Codex remote device that failed or is stuck starting again, once.' },
             'org-name': { type: 'string', value: '<name>', description: 'Name of the organization to create when you have none.' },
             'project-name': { type: 'string', value: '<name>', description: 'Name of the project to create when the organization has none (default Default).' },
             'key-name': { type: 'string', value: '<name>', description: 'Name of the API key (default "shard-cli <hostname>").' },
             tool: { type: 'string', multiple: true, value: '<tool>', description: 'Workspace tool the key may use (repeatable; exec, files, pty, process, git, browser). Default: all.' },
             'new-key': { type: 'boolean', description: 'Create and save a new key even when the saved one works (the old key stays valid until revoked).' },
+            codex: { type: 'boolean', description: 'Set up the account Codex Cloud executor with this machine’s Codex login (default when signed in); --no-codex skips it.' },
         },
-        examples: ['shard setup', 'shard setup --org acme --project web --tool exec --tool files'],
+        examples: ['shard setup', 'shard setup --json --inspect --apps claude,codex', 'shard setup --org acme --project web --tool exec --tool files'],
     },
     {
         path: ['env'],

package/dist/account-commands.js

@@ -1,3 +1,5 @@
+import { prepareOnboardingSample } from "./onboarding-sample.js";
+import { onboardingReport, onboardingText } from "./onboarding.js";
 /**
  * The account plane (0.5.0; docs/progress/account-cli.md §5): everything a person does in the web app, from a
  * terminal. Sign-in and the account calls go through the SDK's ShardfluxAccount with the user session (ctx.account());
@@ -13,11 +15,14 @@
  *   setup), else the only one there is; with several the usage error lists them.
  */
 import { chmod, writeFile } from 'node:fs/promises';
+import { readAgentCredentials, syncAgentCredentials } from "./agent-credentials.js";
 import { API_KEY_TOOL_PERMISSIONS, CheckoutTimeoutError, Shardflux, ShardfluxAccount, ShardfluxApiError, codexIdentityProof, fetchBillingCatalog, parseEmailToken } from '@shardflux/sdk';
 import { CLI_VERSION, UUID, parseDuration, parsePositiveInt } from "./args.js";
 import { openUrl } from "./browser.js";
+import { defaultClientName, startDeviceAuthorization, waitForDeviceSession } from "./browser-login.js";
+import { legalFields, requireTermsAcceptance, showLegalNotice } from "./legal.js";
 import { fileExists, oneOf, out, parseSlugVersion, principal, readInput, resolveWorkspace, str, strs, waitTimeout } from "./commands.js";
-import { AuthConfigError, CheckoutEndedError, InterruptedError, MfaPendingError, NotFoundError, UsageError } from "./errors.js";
+import { AuthConfigError, CheckoutEndedError, InterruptedError, MfaPendingError, NotFoundError, UsageError, describeError } from "./errors.js";
 import { apiKeyTable, attachmentTable, auditTable, authSessionTable, billingStatusText, dataExportText, egressVersionTable, invitationTable, invoiceTable, isGrantPlan, kv, memberTable, money, orgTable, overagePolicyText, planTable, projectEgressText, projectTable, table, time, toolsText, volumeDetail, volumeTable, workspaceEgressText, WORKSPACE_HEADERS, workspaceRow, } from "./format.js";
 export const DEFAULT_API_URL = 'https://api.shardflux.dev';
 const TOTP = /^\d{6}$/;
@@ -283,7 +288,7 @@ async function signedInReport(ctx, account, user, session, extra = {}) {
             ['organizations', memberships === null ? '-' : memberships.length === 0 ? 'none yet' : memberships.map((m) => `${m.organization_name} (${m.organization_slug}, ${m.role})`).join(', ')],
         ]) +
         `next: ${next}\n`;
-    out(ctx, human, { status: 'authenticated', user, session: { expires_at: session.expires_at, credentials_file: ctx.store.file }, organizations: memberships, next, ...extra });
+    out(ctx, human, { status: 'authenticated', user, session: { expires_at: session.expires_at, credentials_file: ctx.store.file }, organizations: memberships, next, ...legalFields(), ...extra });
     return 0;
 }
 /** Best effort: ends a replaced session server side so it does not linger for 30 days. */
@@ -644,6 +649,14 @@ async function runSetup(ctx, values, account) {
             permissions = k.tool_permissions;
     }
     const tag = (made) => (made ? 'created' : 'existing');
+    let codex;
+    const credentialHome = ctx.io.env.HOME ?? ctx.io.env.USERPROFILE;
+    if (values.codex !== false && permissions.includes('exec') && credentialHome && (await readAgentCredentials({ home: credentialHome, redact: value => ctx.addSecret(value) })).some(v => v.app === 'codex')) {
+        const cloud = new Shardflux({ apiKey: key.token, baseUrl: ctx.apiUrl });
+        await syncAgentCredentials(cloud, { home: credentialHome, redact: value => ctx.addSecret(value) });
+        await cloud.codex.enable({ signal: ctx.signal });
+        codex = { ...await cloud.codex.waitConnector({ timeoutMs: ctx.wakeTimeoutMs, signal: ctx.signal }) };
+    }
     const envNote = ctx.io.env.SHARDFLUX_API_KEY?.trim() ? 'note: SHARDFLUX_API_KEY is set in this environment and wins over the saved key; unset it to use the saved key.\n' : '';
     return {
         text: (keep ? 'Already set up; the saved API key works.\n' : 'Set up.\n') +
@@ -653,28 +666,112 @@ async function runSetup(ctx, values, account) {
                 ['api key', `"${key.name}" ${key.key_id} (tools: ${toolsText(permissions)}) ${keep ? 'saved earlier' : 'created'}, saved in ${ctx.store.file}`],
             ]) +
             envNote +
+            (codex ? 'Codex Cloud is ready. One account executor; no pairing. Its residency is billed as workspace usage.\n' : '') +
             `next: ${NEXT_WORKSPACE}\n`,
         data: {
             organization: org,
             project,
             api_key: { id: key.id, key_id: key.key_id, name: key.name, project_id: key.project_id, tool_permissions: permissions },
             created,
+            ...(codex ? { codex } : {}),
             credentials_file: ctx.store.file,
             next: NEXT_WORKSPACE,
         },
     };
 }
+// ---- browser sign-in (0.15.0+) -----------------------------------------------------------------------------------
+/** One NDJSON line of `auth login --browser --json` (the Mac app reads them). */
+function event(ctx, value) {
+    ctx.io.stdout.write(`${JSON.stringify(value)}\n`);
+}
+/**
+ * The browser sign-in (browser-login.ts): starts the request, opens or prints the page and the code, waits for the
+ * approval and saves the session exactly like `auth login` does. With --json the start is the `open` event; a failure
+ * becomes the `error` event (and is thrown on, for the exit code and stderr).
+ */
+async function browserSignIn(ctx, values, noticeShown = false) {
+    try {
+        const opts = ctx.accountOptions();
+        const clientName = str(values['client-name'])?.trim() || defaultClientName(ctx.hostname());
+        const d = await startDeviceAuthorization(opts, clientName, ctx.signal);
+        // The terms notice comes before the browser opens: a line here, the URLs in the event for an app to show. No
+        // --accept-terms: an account created in the browser agrees to the terms on the sign-up page, which records it.
+        if (ctx.json) {
+            event(ctx, { event: 'open', verification_uri_complete: d.verification_uri_complete, user_code: d.user_code, expires_in: d.expires_in, ...legalFields() });
+        }
+        else if (!noticeShown)
+            showLegalNotice(ctx);
+        const opened = values.open !== false && openUrl(d.verification_uri_complete, ctx.io.env);
+        const minutes = Math.max(1, Math.round(d.expires_in / 60));
+        if (!ctx.json) {
+            ctx.io.stderr.write(`${opened ? 'Opening your browser to sign in' : 'Open this page to sign in'}: ${d.verification_uri_complete}\n` +
+                `Your code: ${d.user_code} (approve only if the page shows the same code)\n` +
+                `Waiting for the approval in the browser (the code expires in ${minutes} minutes; Ctrl-C stops)...\n`);
+        }
+        const sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+        const s = await waitForDeviceSession(opts, d, { signal: ctx.signal, sleep });
+        ctx.addSecret(s.session_token);
+        const replaced = ctx.store.profile(ctx.apiUrl).session?.token ?? null;
+        const saved = { token: s.session_token, expires_at: s.session_expires_at || null, user: { id: s.user.id, email: s.user.email }, state: 'active' };
+        const { switched } = ctx.saveSession(saved, s.user.email);
+        if (replaced && replaced !== saved.token)
+            await endQuietly(ctx, replaced);
+        if (switched && !ctx.json)
+            ctx.io.stderr.write(SWITCHED_NOTE);
+        const account = new ShardfluxAccount({ ...ctx.accountOptions(), sessionToken: s.session_token });
+        return { account, user: s.user, saved };
+    }
+    catch (err) {
+        if (ctx.json) {
+            const info = describeError(err);
+            const interrupted = ctx.signal.aborted;
+            event(ctx, { event: 'error', code: interrupted ? 'interrupted' : info.code, message: interrupted ? 'Interrupted.' : info.message });
+        }
+        throw err;
+    }
+}
+/** `shard signup` on a terminal without a Codex login or --email (0.15.0+): the browser sign-in, then setup like signup. */
+async function browserSignup(ctx, values) {
+    // signup has shown the notice (and asked) already.
+    const { account, user } = await browserSignIn(ctx, values, true);
+    let text = `Signed in as ${userLine(user)} in the browser.\nsession: saved in ${ctx.store.file}\n`;
+    const data = { status: 'authenticated', user, method: 'browser', credentials_file: ctx.store.file };
+    if (values.setup !== false) {
+        const setup = await runSetup(ctx, values, account);
+        text += setup.text;
+        data.setup = setup.data;
+    }
+    else {
+        text += 'next: shard setup\n';
+        data.next = 'shard setup';
+    }
+    out(ctx, text, data);
+    return 0;
+}
+/** auth login: --browser, or on a terminal without --email/--codex. */
+function wantsBrowser(ctx, values) {
+    const email = str(values.email) !== undefined;
+    if (values.browser === true) {
+        if (email || values.codex === true)
+            throw new UsageError('use one of --browser, --email or --codex');
+        return true;
+    }
+    if (values.browser === false || email || values.codex === true)
+        return false;
+    return ctx.input.interactive && !ctx.json;
+}
 // ---- handlers --------------------------------------------------------------------------------------------------
 export const ACCOUNT_HANDLERS = {
     async 'auth register'(ctx, values) {
         const email = emailArg(need(values, 'email', '--email you@example.com'), '--email');
         const name = str(values.name)?.trim();
+        const terms = await requireTermsAcceptance(ctx, values);
         const password = await ctx.input.newPassword(`Choose a password for ${email}: `, 'The password', pipe(`shard auth register --email ${email}`));
-        const r = await ShardfluxAccount.register({ ...ctx.accountOptions(), email, password, ...(name ? { displayName: name } : {}) });
+        const r = await ShardfluxAccount.register({ ...ctx.accountOptions(), email, password, ...(name ? { displayName: name } : {}), ...terms });
         const next = [`shard auth verify-email '<link from the email>'`, `${pipe(`shard auth login --email ${email}`)}`];
         out(ctx, `Registration received for ${email}.\n` +
             `Check that inbox for a verification link (valid 24 hours). If the address already has an account, no new one is created: sign in instead.\n` +
-            `next:\n  1. open the link, or: ${next[0]}\n  2. ${next[1]}\n`, { status: r.status, email, next_steps: next });
+            `next:\n  1. open the link, or: ${next[0]}\n  2. ${next[1]}\n`, { status: r.status, email, next_steps: next, ...legalFields() });
         return 0;
     },
     async 'auth verify-email'(ctx, _values, [link]) {
@@ -711,10 +808,26 @@ export const ACCOUNT_HANDLERS = {
         return 0;
     },
     async 'auth login'(ctx, values) {
+        if (wantsBrowser(ctx, values)) {
+            if (factorFlags(values) !== null)
+                throw new UsageError('--code and --recovery-code go with --email; in the browser the sign-in page asks for your second factor');
+            const { account, user, saved } = await browserSignIn(ctx, values);
+            if (ctx.json) {
+                event(ctx, { event: 'signed_in', email: user.email });
+                return 0;
+            }
+            return signedInReport(ctx, account, user, saved);
+        }
+        if (values.open !== undefined || str(values['client-name']) !== undefined)
+            throw new UsageError('--no-open and --client-name go with --browser', 'shard auth login --browser --no-open');
         if (values.codex === true)
             return ACCOUNT_HANDLERS.signup(ctx, { ...values, setup: false, codex: true, email: undefined }, []);
-        const email = emailArg(need(values, 'email', '--email you@example.com'), '--email');
+        const given = str(values.email)?.trim();
+        if (!given)
+            throw new UsageError('--email is required to sign in with a password, e.g. --email you@example.com', 'or sign in with your browser: shard auth login --browser (or with your Codex login: shard auth login --codex)');
+        const email = emailArg(given, '--email');
         let factor = factorFlags(values);
+        showLegalNotice(ctx);
         const password = await ctx.input.secret(`Password for ${email}: `, 'The password', pipe(`shard auth login --email ${email}`));
         let latest = null;
         const { account, result } = await ShardfluxAccount.login({
@@ -971,8 +1084,18 @@ export const ACCOUNT_HANDLERS = {
         return 0;
     },
     async setup(ctx, values) {
+        if (values['prepare-sample'] === true) {
+            const path = await prepareOnboardingSample(ctx.store.dir);
+            out(ctx, `Daylight is ready at ${path}\n`, { sample_path: path });
+            return 0;
+        }
+        if (values.inspect === true || (ctx.json && ctx.sessionSource() === null)) {
+            const onboarding = await onboardingReport(ctx, values);
+            out(ctx, onboardingText(onboarding), { onboarding });
+            return 0;
+        }
         const r = await runSetup(ctx, values, ctx.account());
-        out(ctx, r.text, r.data);
+        out(ctx, r.text, ctx.json ? { ...r.data, onboarding: await onboardingReport(ctx, values) } : r.data);
         return 0;
     },
     async signup(ctx, values) {
@@ -980,6 +1103,10 @@ export const ACCOUNT_HANDLERS = {
         const name = str(values.name)?.trim();
         let codexNote = null;
         let idToken = null;
+        if (values.codex === false && email === undefined)
+            throw new UsageError('--no-codex needs an email address.', 'shard signup --no-codex --email you@example.com');
+        // Before the Codex login is read (its refresh is a network call) and before the API: the agreement to the terms.
+        const terms = await requireTermsAcceptance(ctx, values);
         if (values.codex !== false) {
             const proof = await codexIdentityProof({ env: ctx.io.env, clientName: 'shard', clientVersion: CLI_VERSION });
             if (proof.ok) {
@@ -990,17 +1117,19 @@ export const ACCOUNT_HANDLERS = {
                 }
             }
             else if (email === undefined) {
-                throw new UsageError(`No Codex login to sign up with: ${proof.message}`, 'shard signup --email you@example.com');
+                if (!ctx.input.interactive || ctx.json)
+                    throw new UsageError(`No Codex login to sign up with: ${proof.message}`, 'shard signup --email you@example.com, or in the browser: shard auth login --browser');
+                // On a terminal (0.15.0+): sign up or sign in on the web page instead, then set up as below.
+                ctx.io.stderr.write(`No Codex login on this computer (${proof.message}); continuing in the browser.\n`);
+                return browserSignup(ctx, values);
             }
         }
-        else if (email === undefined) {
-            throw new UsageError('--no-codex needs an email address.', 'shard signup --no-codex --email you@example.com');
-        }
         let latest = null;
         const { account, result } = await ShardfluxAccount.signup({
             ...ctx.accountOptions(),
             ...(idToken !== null ? { codexIdToken: idToken } : { email: email }),
             ...(name ? { displayName: name } : {}),
+            ...terms,
             onSessionToken: (s) => {
                 ctx.addSecret(s.token);
                 latest = s;
@@ -1040,7 +1169,7 @@ export const ACCOUNT_HANDLERS = {
                 ? 'email not verified yet: workspaces run on the Free plan now; verify to start the trial: shard verify'
                 : 'email not verified yet: verify it to run workspaces: shard verify';
         let text = `${result.created ? 'Signed up' : 'Signed in'} as ${userLine(user)} (${how}).\nsession: saved in ${ctx.store.file}\n`;
-        const data = { status: 'authenticated', created: result.created, access, user, method: idToken !== null ? 'codex' : 'email', credentials_file: ctx.store.file };
+        const data = { status: 'authenticated', created: result.created, access, user, method: idToken !== null ? 'codex' : 'email', credentials_file: ctx.store.file, ...legalFields() };
         if (access !== 'verification_required' && values.setup !== false) {
             const setup = await runSetup(ctx, values, account);
             text += setup.text;

package/dist/acp-catalog.js

@@ -2,8 +2,8 @@ import { objectValue } from "./acp-rpc.js";
 // T3's installation probe works offline, without a VM. These are harness
 // labels only. Real sessions always replace them with guest metadata.
 export const ACP_PROBE_CATALOG = {
-    claude: { models: { currentModelId: 'default', availableModels: [{ modelId: 'default', name: 'Claude Code' }] } },
-    codex: { models: { currentModelId: 'default', availableModels: [{ modelId: 'default', name: 'Codex' }] } },
+    claude: { models: { currentModelId: 'default', availableModels: [{ modelId: 'default', name: 'Default' }] } },
+    codex: { models: { currentModelId: 'default', availableModels: [{ modelId: 'default', name: 'Default' }] } },
 };
 export function nativeModelOptions(session) {
     const configs = Array.isArray(session.configOptions) ? session.configOptions.map(objectValue) : [];