uniweb 0.12.35 → 0.12.36

package/src/commands/runtime.js

@@ -76,7 +76,7 @@ export async function runtime(args = []) {
   }
 
   // Version from the SPA build's manifest (the backend keys the version on it);
-  // --version overrides, parity with `uniwebd runtime install --version`.
+  // --version overrides, parity with the backend's runtime install --version.
   let version = readFlagValue(rest, '--version')
   if (!version) {
     try {

package/src/commands/status.js

@@ -24,10 +24,12 @@ import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import yaml from 'js-yaml'
 
-import { resolveSiteDir } from './deploy.js'
+import { resolveSiteDir, resolveSiteBackend } from './deploy.js'
 import { probeUnpushed } from '../backend/site-sync.js'
 import { BackendClient } from '../backend/client.js'
 import { readFlagValue } from '../utils/args.js'
+import { resolveLocalFoundation } from '../backend/foundation-bring-along.js'
+import { computeFoundationDigest } from '../utils/code-upload.js'
 
 const c = {
   reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
@@ -86,16 +88,28 @@ export async function status(args = []) {
   // on 404 / any failure, so a backend without the endpoints just shows local.
   let site = null
   let fdnLatest = null
+  let foundationFresh = null // true/false when both digests are known; else null
   if (remote) {
     try {
       const client = new BackendClient({
         originFlag: readFlagValue(args, '--backend') || readFlagValue(args, '--registry'),
+        siteBackend: await resolveSiteBackend(siteDir),
         token: readFlagValue(args, '--token') || undefined,
         args,
         command: 'Status',
       })
       if (uuid) site = await client.siteStatus(uuid)
-      if (fndScope) fdnLatest = await client.readFoundationLatest(fndScope)
+      // Foundation freshness: prefer the LOCAL foundation's scoped name (so a
+      // local-foundation site can be checked too); fall back to a scoped
+      // site.yml ref. The digest compare is read-only — it never builds, so it
+      // only fires when the local foundation is already built (dist present).
+      const local = resolveLocalFoundation(siteDir, siteYml)
+      const lookupName = local?.scopedName || fndScope
+      if (lookupName) fdnLatest = await client.readFoundationLatest(lookupName)
+      if (local?.dir && fdnLatest?.digest) {
+        const localDigest = computeFoundationDigest(join(local.dir, 'dist'))
+        if (localDigest) foundationFresh = localDigest === fdnLatest.digest
+      }
     } catch {
       // degrade silently
     }
@@ -110,7 +124,7 @@ export async function status(args = []) {
         changed: probe ? probe.changed : null,
         unchanged: probe ? probe.unchanged : null,
         ...(probeErr ? { error: probeErr } : {}),
-        ...(remote ? { remote: { site, foundation_latest: fdnLatest?.latest_version ?? null } } : {}),
+        ...(remote ? { remote: { site, foundation_latest: fdnLatest?.latest_version ?? null, foundation_fresh: foundationFresh } } : {}),
       })
     )
     return { exitCode: 0 }
@@ -123,7 +137,7 @@ export async function status(args = []) {
     say.ok(`Synced — site-content ${c.bold}${uuid}${c.reset}`)
   } else {
     say.warn('Not synced — this site has never been pushed to a backend.')
-    say.dim('Run `uniweb push` to create it, or `uniweb deploy` to ship it in one step.')
+    say.dim('Run `uniweb push` to create it, or `uniweb publish` to sync and go live in one step.')
   }
 
   // Content
@@ -142,7 +156,7 @@ export async function status(args = []) {
         (probe.unchanged ? ` (${probe.unchanged} unchanged)` : '') +
         '.'
     )
-    say.dim('Run `uniweb push` to sync, then `uniweb publish` to go live (or `uniweb deploy` for both).')
+    say.dim('Run `uniweb publish` to sync and go live (or `uniweb push` to sync only).')
   }
 
   // Foundation
@@ -162,6 +176,11 @@ export async function status(args = []) {
     if (fdnLatest?.latest_version && fndVersion && fdnLatest.latest_version !== fndVersion) {
       say.info(`A newer foundation version (${fdnLatest.latest_version}) is registered than the site pins (${fndVersion}).`)
     }
+    if (foundationFresh === false) {
+      say.info('Local foundation differs from the registered version — `uniweb register` (or `uniweb publish`) to release the change.')
+    } else if (foundationFresh === true) {
+      say.ok('Local foundation matches the registered version.')
+    }
     if (!site && !fdnLatest) {
       say.dim('(No remote signals — the backend may not expose them yet.)')
     }

package/src/framework-index.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-06-24T03:15:27.555Z",
+  "generatedAt": "2026-06-25T01:51:21.593Z",
   "packages": {
     "@uniweb/build": {
-      "version": "0.14.18",
+      "version": "0.14.19",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -20,7 +20,7 @@
       "deps": []
     },
     "@uniweb/content-writer": {
-      "version": "0.2.5",
+      "version": "0.2.6",
       "path": "framework/content-writer",
       "deps": []
     },
@@ -99,7 +99,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.4.24",
+      "version": "0.4.25",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",

package/src/index.js

@@ -606,8 +606,10 @@ async function main() {
     process.exit(result?.exitCode ?? 0)
   }
 
-  // Handle register command (dynamic import — depends on @uniweb/build)
-  if (command === 'register') {
+  // Handle register command (dynamic import — depends on @uniweb/build).
+  // `release` is a code-only synonym: `register` reads naturally the first
+  // time, `release` for updates (shipping-model.md §6.1). Same act, same code.
+  if (command === 'register' || command === 'release') {
     const { register } = await importProjectCommand('./commands/register.js')
     const result = await register(args.slice(1))
     process.exit(result?.exitCode ?? 0)
@@ -670,15 +672,16 @@ async function main() {
     return
   }
 
-  // Handle publish command — CMS-publish a SYNCED site (POST /dev/site/publish).
-  // Distinct from `deploy` (file-built host) and `register` (foundation publishing).
+  // Handle publish command — the smart Uniweb-hosting path: bring the
+  // foundation along, sync, settle payment, go live. Distinct from `deploy`
+  // (third-party hosts) and `register`/`release` (foundation code → catalog).
   if (command === 'publish') {
     const { publish } = await importProjectCommand('./commands/publish.js')
     const result = await publish(args.slice(1))
     process.exit(result?.exitCode ?? 0)
   }
 
-  // Handle deploy command (dynamic import — depends on @uniweb/build)
+  // Handle deploy command — third-party hosts only (dynamic import — @uniweb/build)
   if (command === 'deploy') {
     const { deploy } = await importProjectCommand('./commands/deploy.js')
     await deploy(args.slice(1))
@@ -1086,18 +1089,26 @@ async function main() {
  * without loading @uniweb/build or any project context.
  */
 function printCommandHelp(command) {
+  // `release` is a synonym of `register` (shipping-model.md §6.1) — show the
+  // same help block.
+  if (command === 'release') command = 'register'
   const blocks = {
     deploy: `
-${colors.cyan}${colors.bright}uniweb deploy${colors.reset} ${colors.dim}— Deploy a site${colors.reset}
+${colors.cyan}${colors.bright}uniweb deploy${colors.reset} ${colors.dim}— Ship a site to its resolved target${colors.reset}
 
 ${colors.bright}Usage:${colors.reset}
-  uniweb deploy [options]
+  uniweb deploy --host <name> [options]
 
-The host is determined by the resolved deploy.yml target. Defaults to
-${colors.cyan}uniweb${colors.reset} hosting (link-mode, edge JIT prerender) when no deploy.yml exists.
+Ships a site to its resolved target. A THIRD-PARTY host builds dist/ (bundle
+mode) and hands it to a host adapter for upload + invalidation. A UNIWEB target
+(\`--host=uniweb\`, or a \`uniweb\` target in deploy.yml) delegates to
+${colors.cyan}uniweb publish${colors.reset} (sync + dynamic serving; brings the foundation along) — the
+canonical direct verb for Uniweb hosting. With no host chosen, deploy prompts for
+a third-party adapter. For a self-contained dist/ you upload yourself, use
+${colors.cyan}uniweb export${colors.reset}.
 
 ${colors.bright}Hosts:${colors.reset}
-  uniweb              Uniweb hosting (default; requires \`uniweb login\`)
+  uniweb              Uniweb hosting (delegates to \`uniweb publish\`)
   cloudflare-pages    Cloudflare Pages (build artifact + adapter postBuild)
   netlify             Netlify (alias of cloudflare-pages adapter)
   vercel              Vercel (build-only — deploy via \`npx vercel\`)
@@ -1106,43 +1117,40 @@ ${colors.bright}Hosts:${colors.reset}
   generic-static      Plain static-host build, no host-specific helpers
 
 ${colors.bright}Options:${colors.reset}
+  --host <name>       The host to ship to (no value → interactive third-party picker, TTY only)
   --target <name>     Pick a target from deploy.yml (default: deploy.yml's \`default:\`)
-  --host <name>       Override the resolved target's host (does not persist)
-  --host              No value → interactive picker (TTY only)
-  --dry-run           Resolve site.yml + foundation/runtime; print summary; no writes
-  --no-auto-publish   Don't auto-publish workspace-local foundation as part of deploy
+  --dry-run           Resolve the target + adapter; print summary; upload nothing
   --no-save           Skip the auto-save of lastDeploy in deploy.yml
-  --backend <url>     Override the default backend origin (\$UNIWEB_REGISTER_URL or built-in)
   --non-interactive   Fail with usage info instead of prompting
 
-${colors.bright}Auth:${colors.reset}
-  \`host: uniweb\` requires authentication. Run \`uniweb login\` first, set
-  \`UNIWEB_TOKEN=<bearer>\` env var, or use a static-host adapter that
-  doesn't need a Uniweb account. CI / agents / piped stdin auto-detect
-  non-interactive mode and bail with an actionable error instead of
-  hanging on a browser callback.
-
 ${colors.bright}Examples:${colors.reset}
-  uniweb deploy                              # Default (host=uniweb)
-  uniweb deploy --dry-run                    # Print summary, no writes
-  uniweb deploy --host=cloudflare-pages      # One-off override
-  uniweb deploy --target=preview             # Pick named target from deploy.yml
+  uniweb deploy --host=cloudflare-pages      # Build + upload to Cloudflare Pages
+  uniweb deploy --host=s3-cloudfront         # Build + upload + invalidate
+  uniweb deploy --host=uniweb                # → delegates to \`uniweb publish\`
+  uniweb deploy --target=preview             # Named target from deploy.yml
 `,
     publish: `
-${colors.cyan}${colors.bright}uniweb publish${colors.reset} ${colors.dim}— Publish a synced site (make its backend state live)${colors.reset}
+${colors.cyan}${colors.bright}uniweb publish${colors.reset} ${colors.dim}— Publish a site to Uniweb hosting (the smart path)${colors.reset}
 
 ${colors.bright}Usage:${colors.reset}
   uniweb publish [options]
 
-Publishes a site that's synced to the backend (has site.yml::\$uuid from
-\`uniweb push\`) — makes its CURRENT backend state live, including edits made
-through the app. Run \`uniweb push\` first to include local edits. For a
-file-only site use \`uniweb deploy\`; to register a FOUNDATION use \`uniweb register\`.
+The most ergonomic command in the tool: \`uniweb login && uniweb publish\` reads
+your project and makes the site live on Uniweb hosting. It resolves which site,
+BRINGS THE FOUNDATION ALONG (releases the local foundation when its code
+changed), syncs content, settles payment when go-live needs it (a browser
+handoff), and goes live. A published-registry foundation needs no release; an
+already-paid site opens no browser.
+
+For a third-party host use \`uniweb deploy --host=<name>\`; to register a
+FOUNDATION on its own use \`uniweb register\` (alias \`uniweb release\`).
 
 ${colors.bright}Options:${colors.reset}
+  --dry-run          Resolve everything; release/sync/POST nothing
+  --yes              Skip confirmations (CI); never block on a prompt
+  --no-save          Skip the deploy.yml lastDeploy auto-save
   --backend <url>    Backend origin (default: \$UNIWEB_REGISTER_URL or built-in)
   --token <bearer>   Auth bearer (skips \`uniweb login\`)
-  --dry-run          Resolve everything; POST nothing
 `,
     create: `
 ${colors.cyan}${colors.bright}uniweb create${colors.reset} ${colors.dim}— Create a new project${colors.reset}
@@ -1276,15 +1284,18 @@ ${colors.bright}Options:${colors.reset}
 Exit codes: 0 clean (or warn-only), 1 violations under --strict, 2 setup error.
 `,
     register: `
-${colors.cyan}${colors.bright}uniweb register${colors.reset} ${colors.dim}— Register a foundation + its data schemas with the backend registry${colors.reset}
+${colors.cyan}${colors.bright}uniweb register${colors.reset} ${colors.dim}— Register (release) a foundation + its data schemas with the backend registry${colors.reset}
 
 ${colors.bright}Usage:${colors.reset}
   uniweb register [options]
+  uniweb release  [options]      ${colors.dim}(synonym — reads naturally for updates)${colors.reset}
 
 Builds one \`.uwx\` document and submits it to the registry over HTTP. Run
-\`uniweb login\` first (or pass \`--token\`). \`register\` is for FOUNDATIONS (and
-schemas); \`uniweb publish\` makes a synced SITE live; \`uniweb deploy\` hosts a
-file-built site.
+\`uniweb login\` first (or pass \`--token\`). \`register\`/\`release\` are for
+FOUNDATIONS (and schemas) — code only; \`uniweb publish\` makes a synced SITE
+live (and brings its foundation along); \`uniweb deploy\` hosts on a third-party
+host. \`register\` and \`release\` are the same act: \`register\` reads naturally
+the first time, \`release\` for updates.
 
 Auto-detects what you run it in:
   • a foundation        the foundation + the data schemas it defines/renders
@@ -1300,7 +1311,7 @@ ${colors.bright}Options:${colors.reset}
   --scope @org       Publish under @org (resolves @/x -> @org/x); default: package.json uniweb.scope
   --dry-run          Print the .uwx; submit nothing
   -o, --output <f>   Write the .uwx to a file; submit nothing
-  --registry <url>   Submit endpoint (default: \$UNIWEB_REGISTER_URL or a local URL)
+  --backend <url>    Backend origin (alias: --registry; default: \$UNIWEB_REGISTER_URL or a local URL)
   --token <bearer>   Submit with this bearer; skips \`uniweb login\` (or set UNIWEB_TOKEN)
   --non-interactive  Fail with usage info instead of prompting
 
@@ -1470,10 +1481,11 @@ ${colors.bright}Commands:${colors.reset}
   rename <type>      Rename a foundation, site, or extension across the workspace
   dev                Start a dev server for a site
   build              Build the current project
-  deploy             Deploy a site to Uniweb hosting
+  publish            Publish a site to Uniweb hosting (smart: foundation + sync + go live)
+  deploy             Deploy a site to a third-party host (--host=<adapter>)
   export             Export a self-contained site for third-party hosting
-  publish            Publish a synced site (make its backend state live)
   register           Register a foundation + its data schemas with the backend registry
+  release            Release a foundation version (synonym of register)
   runtime register   Register an @uniweb/runtime version to the backend (@std only)
   push               Push a site's content to the backend
   pull               Pull a site's content from the backend
@@ -1506,21 +1518,24 @@ ${colors.bright}Global Options:${colors.reset}
                        Auto-detected when CI=true or no TTY (pipes, agents)
 
 ${colors.bright}Publish Options:${colors.reset}
+  --dry-run          Resolve everything; release/sync/POST nothing
+  --yes              Skip confirmations (CI); never block on a prompt
+  --no-save          Skip the deploy.yml lastDeploy auto-save
   --backend <url>    Backend origin (default: \$UNIWEB_REGISTER_URL or built-in)
   --token <bearer>   Auth bearer (skips \`uniweb login\`)
-  --dry-run          Resolve everything; POST nothing
 
-  uniweb publish makes a SYNCED site live (run \`uniweb push\` first). To register
-  a foundation use \`uniweb register\`; to host a file-built site use \`uniweb deploy\`.
+  uniweb publish is the smart Uniweb-hosting path: it brings the site's
+  foundation along, syncs, and goes live. To register a foundation on its own
+  use \`uniweb register\` (alias \`uniweb release\`); for a third-party host use
+  \`uniweb deploy --host=<name>\`.
 
 ${colors.bright}Deploy Options:${colors.reset}
+  --host <name>      The host to ship to (no value → interactive third-party
+                     picker, TTY only). Third-party: cloudflare-pages, netlify,
+                     vercel, github-pages, s3-cloudfront, generic-static.
+                     \`--host=uniweb\` delegates to \`uniweb publish\`.
   --target <name>    Pick a target from deploy.yml (default: deploy.yml's \`default:\`)
-  --host <name>      Override the resolved target's host (does not persist).
-                     Without a value, opens an interactive picker (TTY only).
-                     Hosts: uniweb, cloudflare-pages, netlify, vercel,
-                     github-pages, s3-cloudfront, generic-static.
-  --dry-run          Resolve site.yml + foundation/runtime; print summary; no writes
-  --no-auto-publish  Don't auto-publish workspace-local foundation as part of deploy
+  --dry-run          Resolve the target + adapter; print summary; upload nothing
   --no-save          Skip the auto-save of lastDeploy in deploy.yml
 
 ${colors.bright}Dev Options:${colors.reset}

package/src/utils/asset-upload.js

@@ -1,8 +1,8 @@
 /**
- * Site asset delivery — the asset lane for `uniweb deploy` (channel
+ * Site asset delivery — the asset lane for `uniweb publish` (channel
  * framework-backend-f90d). After the link build processes a site's media into
  * `dist/assets/`, those bytes are delivered to the backend's content-addressed
- * asset store, and the deploy step rewrites the content's local refs to durable
+ * asset store, and the publish step rewrites the content's local refs to durable
  * serve URLs:
  *
  *   1. PLAN   — POST {apiBase}/dev/assets with the file list ({ path,
@@ -147,7 +147,7 @@ export async function uploadSiteAssets({ apiBase, token, distDir, files, onProgr
     onProgress(`↑ ${src.path}`)
     let putRes
     try {
-      // The plan's url may be origin-relative (direct mode → uniwebd) or
+      // The plan's url may be origin-relative (direct mode → the backend) or
       // absolute (presigned → storage); new URL() resolves both.
       putRes = await fetch(new URL(up.url, origin), { method: up.method || 'PUT', headers, body: src.bytes ?? readFileSync(src.diskPath) })
     } catch (err) {

package/src/utils/code-upload.js

@@ -8,7 +8,7 @@
  *   1. PLAN   — POST {apiBase}/dev/registry/code-uploads with the file list
  *               ({ path, content_type, size, sha256? }). The response carries
  *               one upload target per file ({ path, method, url, headers })
- *               plus mode: 'direct' (dev — URLs point back at uniwebd) or
+ *               plus mode: 'direct' (dev — URLs point back at the backend) or
  *               'presigned' (prod — storage PUTs; bytes never transit the
  *               backend). The CLI never branches on the mode.
  *   2. UPLOAD — PUT each file's raw bytes to its URL with the given headers.
@@ -35,7 +35,7 @@
  */
 
 import { createHash } from 'node:crypto'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 
 // Extension → declared content type. Extension-honest by construction (Vite
@@ -111,6 +111,46 @@ export function uploadOrder(files) {
   return [...rest, ...entry]
 }
 
+/**
+ * The deterministic content digest of a built foundation — the freshness
+ * fingerprint `register` records and `publish`/`status` later compare against
+ * (shipping-model.md §4.1). It answers one question — "did the foundation change
+ * since it was released?" — with NO local state, so it has to be reproducible:
+ * the same source, built on any machine, must yield the same digest.
+ *
+ * Algorithm (§4.1): `sha256` over the newline-joined, SORTED list of the
+ * per-file `sha256` (hex) of exactly what `register` ships for a foundation —
+ *   - the code-upload set (`collectDistFiles`: entry + chunks + assets, with
+ *     `meta/**` and `*.map` already excluded), and
+ *   - the schema source (`meta/schema.json`) — NOT uploaded as a file, and not
+ *     sent verbatim: register submits its *content* as the foundation-schema
+ *     ENTITY in the `.uwx`. It's read here only to fold the schema into the
+ *     local freshness fingerprint (so a schema edit shows as "changed").
+ * Hashes are SORTED (so the digest is order-independent) and taken over file
+ * CONTENTS, not names, so content-hashed chunk filenames don't perturb it.
+ * Returns null when there's nothing to hash (no usable dist), so callers skip
+ * cleanly rather than fingerprinting emptiness.
+ *
+ * The result is OPAQUE to the backend — it stores the string and returns it
+ * verbatim; the framework owns the algorithm end-to-end and can change it
+ * freely (a digest only ever compares against one the same CLI computed).
+ *
+ * @param {string} distDir - the built `dist/` directory
+ * @returns {string|null} `sha256:<hex>` or null when there's nothing to hash
+ */
+export function computeFoundationDigest(distDir) {
+  const hashes = collectDistFiles(distDir).map((f) => f.sha256)
+  // The schema rides in the register `.uwx`, not the code-upload set, so fold
+  // it in explicitly — a schema-only change is still a foundation change.
+  const schemaPath = join(distDir, 'meta', 'schema.json')
+  if (existsSync(schemaPath)) {
+    hashes.push(createHash('sha256').update(readFileSync(schemaPath)).digest('hex'))
+  }
+  if (!hashes.length) return null
+  hashes.sort()
+  return 'sha256:' + createHash('sha256').update(hashes.join('\n')).digest('hex')
+}
+
 /**
  * The gateway serve URL for a file of a registered foundation version.
  * Mirrors the backend storage convention: scope WITHOUT the '@'.
@@ -180,7 +220,7 @@ export async function uploadFoundationCode({
   const plan = await planRes.json()
   const targets = new Map((plan.uploads || []).map((u) => [u.path, u]))
   const serveBase = plan.serve_base || null
-  // The ONE mode-aware bit: direct-mode PUTs are bearer-authed uniwebd
+  // The ONE mode-aware bit: direct-mode PUTs are bearer-authed backend
   // routes; presigned URLs are self-authorizing and must NOT carry a
   // bearer (foreign auth headers can break signed-request validation).
   const authHeaders = plan.mode === 'direct' ? { Authorization: `Bearer ${token}` } : {}

package/src/utils/config.js

@@ -49,14 +49,35 @@ function readCliConfig() {
   return _cliConfig
 }
 
+/**
+ * The origin the LAST `uniweb login` authenticated against — persisted on the
+ * session record so subsequent verbs default to the backend you logged into
+ * (no `--backend` per command). Sync read; null when there's no session or it
+ * carries no origin (older sessions). Read directly (not via registry-auth.js)
+ * to keep this module off the optional-peer / import-cycle path.
+ * @returns {string|null}
+ */
+function readSessionOrigin() {
+  try {
+    const p = join(homedir(), '.uniweb', 'registry-auth.json')
+    if (!existsSync(p)) return null
+    const o = JSON.parse(readFileSync(p, 'utf8'))?.origin
+    return o || null
+  } catch {
+    return null
+  }
+}
+
 /**
  * Get the backend's API base origin. `register` POSTs to
  * {origin}/dev/registry/register, `login` to {origin}/dev/auth/login, etc.
- * (BackendClient.resolveBackendOrigin layers the --backend/--registry flag on
- * top of this.)
+ * (BackendClient.resolveBackendOrigin layers the --backend flag and a site's
+ * deploy.yml backend on top of this.)
  *
- * Priority: UNIWEB_REGISTER_URL's origin > ~/.uniweb/config.json registryApiUrl
- * > local default.
+ * Priority: UNIWEB_REGISTER_URL's origin > the logged-in session origin >
+ * ~/.uniweb/config.json registryApiUrl > the default (uniweb.app). Local dev
+ * points at a local backend EXPLICITLY (--backend / UNIWEB_REGISTER_URL /
+ * `uniweb login --backend …`), rather than the default being localhost.
  * @returns {string}
  */
 export function getRegistryApiBaseUrl() {
@@ -64,11 +85,15 @@ export function getRegistryApiBaseUrl() {
   if (fromEnv) {
     try { return new URL(fromEnv).origin } catch { /* fall through */ }
   }
+  const fromSession = readSessionOrigin()
+  if (fromSession) {
+    try { return new URL(fromSession).origin } catch { return fromSession }
+  }
   const fromCfg = readCliConfig().registryApiUrl
   if (fromCfg) {
     try { return new URL(fromCfg).origin } catch { return fromCfg }
   }
-  return 'http://localhost:8080'
+  return 'https://uniweb.app'
 }
 
 /**