constellai 0.3.6 → 0.3.8

package/docs/en/CHAT_COMMANDS.md

@@ -212,7 +212,7 @@ Every command parsed by `runSlashCommand`, grouped by category. "Responds as" is
 /graph SPEC-01
 /reindex
 /curate
-/new-goal a billing page with Stripe checkout
+/new-goal a billing page with payment-provider checkout
 /new-work add 2FA to the login screen
 /generate-plan migrate the database to Postgres
 /approve

package/docs/en/CONFIGURATION.md

@@ -314,7 +314,7 @@ node scripts/mcp-server.mjs
 - `src/lib/scrub.ts` scrubs `CONSTELLA_VAULT_KEY`, `BETTER_AUTH_SECRET` and `CONSTELLA_WORKER_SECRET` before KB ingest, Telegram and logs.
 - The worker enforces a **loopback-only SSRF guard** on `CONSTELLA_BASE_URL`.
 - `process.env` always overrides the `.env` file — operators control configuration via the shell/Docker/systemd, not via an attacker-writable file.
-- Agent permissions degrade safely: full access only with `--start` (your own machine); `--vps`/`--portable` stay jailed (Docker + Tailscale as the hard jail). Authentication (email + password) is required on every target. See [SECURITY](./SECURITY.md).
+- Agent permissions degrade safely: full access only with `--start` (your own machine); `--vps`/`--portable` stay jailed (the host + Tailscale tailnet as the hard boundary). Authentication (email + password) is required on every target. See [SECURITY](./SECURITY.md).
 
 ---
 

package/docs/en/DESIGN.md

@@ -96,7 +96,7 @@ The **Docs** rail renders Grace's written documentation as markdown: `design-sys
 ## RAG & skill selection 🌌
 
 Grace doesn't read a flat skill list. She **extracts keywords** from the brief, mission, objective, attached mock and
-your message, **expands** them through a domain + style lexicon (hotel → booking / hospitality / rooms; "Apple/iOS" →
+your message, **expands** them through a domain + style lexicon (hotel → booking / hospitality / rooms; "native mobile" →
 glassmorphism / microinteractions / premium typography), and **ranks the seeded skills** by name / tags / description —
 then reads the most relevant ones first. Domain- and style-aware, not generic.
 

package/docs/en/FAQ.md

@@ -114,7 +114,7 @@ The workspace directory is the **source of truth** (`src/lib/fs-workspace.ts`);
 Yes — two supported patterns, plus a caveat:
 
 - **Portable** (`--portable`): the runtime root lives on a **USB drive** mounted as root, carried between machines. Requires `>=32GB` free (fatal below that); `>=32GB` is fine. Binds `0.0.0.0`. Login (email + password) is required — as it is everywhere.
-- **VPS** (`--vps`): Constella runs in Docker on a server and you reach it over your **Tailscale tailnet**. Binds `0.0.0.0`. Login (email + password) required, same as every target.
+- **VPS** (`--vps`): Constella runs natively on a server (npm + systemd) and you reach it over your **Tailscale tailnet** — no Docker; the host itself is the tailnet node. Binds `0.0.0.0`. Login (email + password) required, same as every target.
 
 Caveat: the CLI subscription credentials (`~/.claude/.credentials.json`) live on the host running the agents. Constella copies the operator's Claude credentials into a clean per-agent config dir so agents stay logged in (see Q8), but the **host machine** still needs a valid CLI login. Portable mode carries Constella's data, not necessarily every CLI's auth.
 
@@ -131,14 +131,14 @@ The launch flag is an **install target** (`src/lib/run-mode.ts`), not an auth mo
 | Install target | Launch flag | Bind | Best for |
 | --- | --- | --- | --- |
 | Local (default) | `--start` | `127.0.0.1` | Solo local use on your own machine; agents get **full access** (install deps, run tests) |
-| VPS | `--vps` | `0.0.0.0` | A shared server over Tailscale, runs in Docker; agents **jailed** to edits-only |
+| VPS | `--vps` | `0.0.0.0` | A shared server over Tailscale (native npm + systemd, no Docker); agents **jailed** to edits-only |
 | USB | `--portable` | `0.0.0.0` | A USB you carry between machines; agents **jailed** |
 
 ```mermaid
 flowchart TD
   Q{"Where will it run?"}
   Q -->|My own machine| START["--start local, full agent access"]
-  Q -->|A server I reach remotely| VPS["--vps Docker + Tailscale"]
+  Q -->|A server I reach remotely| VPS["--vps native + Tailscale"]
   Q -->|A USB I carry around| PORT["--portable"]
   START --> AUTH["all targets: signup then login<br/>email + password"]
   VPS --> AUTH

package/docs/en/GOALS_SPECS_ISSUES.md

@@ -230,7 +230,7 @@ stateDiagram-v2
 **New work from a DM** (handled by `planFromConversationFor` → `generatePlanFor`):
 
 ```
-@ada build a billing dashboard with Stripe and a CSV export
+@ada build a billing dashboard with a payment provider and a CSV export
 ```
 
 **Approve from a slash command** ([CHAT_COMMANDS](./CHAT_COMMANDS.md)):

package/docs/en/MCP.md

@@ -33,7 +33,7 @@ scripts/mcp-server.mjs  ──Bearer cn_…──►  /api/v1/[[...path]]  ─
 
 Key properties straight from the source:
 
-- **Zero dependencies.** `scripts/mcp-server.mjs` imports only `node:readline` and uses the global `fetch` (Node 18+). It ships in the compiled distribution unchanged.
+- **Zero dependencies.** `scripts/mcp-server.mjs` imports only `node:readline` and uses the global `fetch` (Node 18+). It ships in the package unchanged.
 - **Hand-rolled MCP.** It implements the JSON-RPC methods `initialize`, `notifications/initialized`, `ping`, `tools/list` and `tools/call` directly — no SDK.
 - **Thin mapping.** Every tool's `build(args)` returns `{ method, path, body? }`, which `callApi` sends to `${BASE}/api/v1${path}` with `Authorization: Bearer ${PAT}` (and `x-constella-org` when `CONSTELLA_ORG` is set).
 - **One credential.** The REST layer (`authenticatePAT` in `src/server/api/pat-auth.ts`) is PAT-only; there is no session. Scope (`read` / `write`) is enforced server-side.
@@ -164,7 +164,7 @@ The MCP server talks to a live server at `CONSTELLA_BASE_URL` (default `http://l
   "mcpServers": {
     "constella": {
       "command": "node",
-      "args": ["C:/Users/Usuario/Documents/constella/scripts/mcp-server.mjs"],
+      "args": ["/path/to/constella/scripts/mcp-server.mjs"],
       "env": {
         "CONSTELLA_PAT": "cn_your_write_token_here",
         "CONSTELLA_BASE_URL": "http://localhost:3000"

package/docs/en/PLUGINS.md

@@ -179,7 +179,7 @@ Two crucial clarifications:
 ### "Install" a placeholder plugin (PARTIAL)
 
 1. Click **Install from URL** in the topbar.
-2. The browser `window.prompt` asks for a URL or name (placeholder text: `github.com/acme/slack-bridge`).
+2. The browser `window.prompt` asks for a URL or name (placeholder text: `github.com/acme/chat-bridge`).
 3. `installPlugin(url.trim())` inserts a non-native row, `enabled: true`, `description: "Installed from URL"`.
 4. Nothing is downloaded or wired. The row is a bookmark only — **this is a mock** (see [Possible states](#possible-states-)).
 
@@ -208,7 +208,7 @@ await togglePlugin(githubPluginId, false);
 ```ts
 import { installPlugin } from "@/server/actions/plugin-actions";
 
-const res = await installPlugin("github.com/acme/slack-bridge");
+const res = await installPlugin("github.com/acme/chat-bridge");
 // res => { ok: true }
 // A non-native row appears in /plugins, enabled, description "Installed from URL".
 // No bridge code runs — it is a catalog bookmark.

package/docs/en/PORTABLE_MODE.md

@@ -347,7 +347,7 @@ $ npx constellai --portable
 
 - **Update** ([UPDATE](./UPDATE.md)) — `detectRunContext()` returns `"portable"`; `startUpdate()` does **not** auto-run on portable. It backs up `.env` + db to `<USB>/.constella/backups/<timestamp>/`, then returns the command and *"Portable: ensure free space, back up the drive, then run: `npm install -g constellai@latest`"* with `needsRestart: true`.
 - **Local models / RAG** ([MODELS](./MODELS.md), [MEMORY_RAG](./MEMORY_RAG.md)) — GGUF models and embed/chat servers run off the drive's runtime root; the 32 GB minimum boots, but local models are why you'd carry a larger drive.
-- **VPS** ([VPS_MODE](./VPS_MODE.md)) — shares the `0.0.0.0` bind; differs in that VPS runs in Docker over a tailnet, portable runs off a drive.
+- **VPS** ([VPS_MODE](./VPS_MODE.md)) — shares the `0.0.0.0` bind; differs in that VPS runs natively on a host over a tailnet (no Docker), portable runs off a drive.
 - **Configuration** ([CONFIGURATION](./CONFIGURATION.md)) — `CONSTELLA_HOME`, `CONSTELLA_RUN_MODE`, `DATABASE_URL` and the secret env vars are documented there.
 
 ---

package/docs/en/PUBLISHING.md

@@ -4,9 +4,9 @@
 
 ![](../assets/divider-orbit.svg)
 
-Publishing is how the central ship leaves the shipyard. Two launches happen, in two directions: the **npm tarball** carries the *compiled runtime* to end users, and the **public Git mirror** carries the *product tree* (docs, launcher, migrations — no source) to `github.com/gabriel7silva/constella`. The private development tree stays home, in orbit, on the `dev` remote. ✦
+Publishing is how the central ship leaves the shipyard. Two launches happen, in two directions: the **npm tarball** carries the *compiled runtime* to end users (the prebuilt `.next`, no build step), and the **public Git repo** carries the *full open-source tree* (`src/`, docs, launcher, migrations) to `github.com/gabriel7silva/constella`. ✦
 
-> **TL;DR** — End users receive a compiled, minified runtime, **never `src/`**. `npm publish` ships the prebuilt `.next`; `scripts/publish-public.mjs --push` mirrors a clean, secret-scanned, source-free tree to the public Git repo. Both refuse to ship secrets.
+> **TL;DR** — End users of the **npm package** receive a compiled, minified runtime (the prebuilt `.next`, no build step) — the tarball never carries `src/`. The **public Git repo** is the open source. `npm publish` ships the prebuilt `.next`; `scripts/publish-public.mjs --push` mirrors a clean, secret-scanned tree to the public Git repo. Both refuse to ship secrets.
 
 ---
 
@@ -27,7 +27,7 @@ This page covers the **two distribution channels** and the gates that protect th
 
 ## How it works 🌌
 
-Constella distributes through **two channels** that share one principle: *ship the product, never the source.*
+Constella distributes through **two channels**: the npm tarball ships the *compiled runtime* (no `src/` in the package), while the public Git repo ships the *open source*.
 
 ```
             ┌────────────────────── dev tree (private) ──────────────────────┐
@@ -42,13 +42,13 @@ Constella distributes through **two channels** that share one principle: *ship t
    │ npm registry: constellai    │               │ public Git: gabriel7silva/      │
    │ COMPILED runtime tarball     │               │ constella (force-pushed mirror) │
    │ .next + bin + drizzle + docs │               │ docs + bin + drizzle + skills   │
-   │ NO src/                      │               │ NO src/, NO .next, NO secrets   │
+   │ NO src/                      │               │ FULL src/ · no .next/secrets   │
    └─────────────────────────────┘               └────────────────────────────────┘
 ```
 
 1. **npm channel** — `npm publish` ships the runtime as a tarball. The `files` allowlist in `package.json` selects exactly what travels; `prepublishOnly` validates the tree; `prepack` (`trim-next.mjs`) strips dev artifacts from `.next` so end users receive only the production runtime.
 2. **Git channel** — `scripts/publish-public.mjs` builds a filtered tree in a *temporary* git index (HEAD minus `src/`/tests, plus the generated `drizzle/` migrations), secret-scans exactly that set, and **force-pushes** it as a fresh root commit to the `public` remote. The compiled `.next` does **not** travel through git — it reaches users via the npm tarball.
-3. **Dual-repo** — the private `dev` remote (`constella-Dev`) keeps the full source history; the `public` remote (`constella`) is a clean, disposable mirror, not a shared history.
+3. **Public repo** — the `public` remote (`constella`) is the open-source home, carrying the full `src/` tree.
 
 > Neither channel carries `src/`. The schema reaches users as generated SQL under `drizzle/`, applied by `drizzle-kit migrate`. See [INSTALLATION](./INSTALLATION.md).
 
@@ -151,7 +151,7 @@ Because the `files` allowlist re-includes the **whole** `.next` directory (overr
 
 ### `publish-public.mjs` — the clean Git mirror
 
-`scripts/publish-public.mjs` produces the **source-free** Git mirror. It never runs automatically; you invoke it deliberately.
+`scripts/publish-public.mjs` produces the open-source public Git tree. It never runs automatically; you invoke it deliberately.
 
 The constant that defines the whole point:
 
@@ -186,10 +186,9 @@ Flow inside the script:
 
 | Remote | Repository | Contains | History |
 | --- | --- | --- | --- |
-| `dev` | `gabriel7silva/constella-Dev` | Full private source tree (`src/`, tests, e2e, history) | Real, preserved |
-| `public` | `gabriel7silva/constella` | Product only (docs, `bin/`, `drizzle/`, `skills/`, configs) | Disposable — overwritten by force-push |
+| `public` | `gabriel7silva/constella` | Open-source tree (`src/`, docs, `bin/`, `drizzle/`, `skills/`, configs) | Maintained history |
 
-The public mirror is **not** a shared-history collaboration target. Each `--push` writes a fresh root commit and force-overwrites `main`. Development happens against `dev`; the npm tarball is published separately from either git push.
+The npm tarball is published separately from the git push.
 
 ---
 
@@ -220,7 +219,7 @@ tar -tf constellai-0.1.0.tgz | sort   # inspect what would ship — confirm no s
 ```bash
 # Dry run — generate migrations if needed, compute the publish set, secret-scan, print the count:
 node scripts/publish-public.mjs
-#   ✓ Clean: <N> files to publish (no src/, no secrets). Migrations: <M> file(s).
+#   ✓ Clean: <N> files to publish (full source, no secrets). Migrations: <M> file(s).
 
 # Push — build the filtered tree in a temp index and force-push to public main:
 node scripts/publish-public.mjs --push
@@ -243,9 +242,9 @@ npm run clean    # scripts/clean-repo.mjs — removes scratch artifacts at the r
 
 ```text
 $ node scripts/publish-public.mjs
-✓ Clean: 412 files to publish (no src/, no secrets). Migrations: 7 file(s).
+✓ Clean: 1712 files to publish (full source, no secrets). Migrations: 7 file(s).
 
-Dry run. To publish the clean compiled tree to the public repo, run:
+Dry run. To publish the clean tree to the public repo, run:
   node scripts/publish-public.mjs --push
 ```
 
@@ -305,8 +304,8 @@ Publishing is a high-trust operation; the design assumes a mistake *will* happen
 - **Source never ships.** Both channels exclude `src/`. The Git mirror checks twice — `EXCLUDE` filters it out, then a final pass aborts if any `src/` path survived.
 - **Secret-scan refuses on any finding.** `publish-public.mjs` blocks on the **first** match per file across 10 inline patterns + a sensitive-filename rule. It is deliberately conservative (`512 KB` text-file cap, placeholder-credential allowance to avoid false positives in docs).
 - **`.env` and DB files are sensitive by filename.** They are blocked even if you never opened them — except the explicit allowlist (`.env.example`, etc.) and `drizzle/*.sql` DDL.
-- **Force-push is intentional.** The public repo is a *clean mirror*, not a collaboration history. It carries no `.next` and no secrets, so overwriting it is safe by construction.
-- **The tarball is compiled.** End users run a minified `.next` and applied SQL migrations — no readable application source, no devDependencies.
+- **The public repo carries no secrets.** The publish set is secret-scanned before every push; it carries no `.next` and no `.env`.
+- **The npm tarball is compiled.** End users of the package run a minified `.next` and applied SQL migrations — no build step, no devDependencies. (The source itself is open on GitHub.)
 - **Secrets live outside the tree.** Runtime secrets are persisted to `<HOME>/.env` (`chmod 600`) and never in the repo; the vault key, worker secret and auth secret are generated at first boot. See [SECURITY](./SECURITY.md).
 
 > The scanner is a safety net, not a substitute for discipline. Keep secrets in `<HOME>/.env` and the vault, never in tracked files.
@@ -340,4 +339,4 @@ Publishing is a high-trust operation; the design assumes a mistake *will* happen
 
 ---
 
-<sub>✦ The shipyard is quiet, the launch is loud. Ship the product, keep the blueprints. 🚀</sub>
+<sub>✦ The shipyard is quiet, the launch is loud. Ship the product, open the blueprints. 🚀</sub>

package/docs/en/README.md

@@ -28,7 +28,7 @@ Auth is always required (email + password), identical everywhere — the launch
 | Doc | What it covers |
 |-----|----------------|
 | [Start (local)](START_MODE.md) | `constella --start`, binds `127.0.0.1` — the default local install |
-| [VPS](VPS_MODE.md) | `constella --vps`, binds `0.0.0.0` over a Tailscale tailnet, Docker |
+| [VPS](VPS_MODE.md) | `constella --vps`, binds `0.0.0.0` over a Tailscale tailnet (native, no Docker) |
 | [Portable (USB)](PORTABLE_MODE.md) | `constella --portable`, runs off a USB drive, binds `0.0.0.0` |
 
 ## 🛰️ Architecture

package/docs/en/SECURITY.md

@@ -26,7 +26,7 @@ Constella layers independent controls so no single failure is catastrophic. The
 ```mermaid
 flowchart TB
   subgraph Edge["🛰️ Network edge"]
-    A1["Run-mode bind: start/auth = 127.0.0.1 · vps/portable = 0.0.0.0 + Tailscale/Docker"]
+    A1["Run-mode bind: start/auth = 127.0.0.1 · vps/portable = 0.0.0.0 + Tailscale"]
     A2["better-auth session gate (email+password · TOTP 2FA · WebAuthn passkeys)"]
     A3["Worker endpoints: x-worker-secret, fail CLOSED"]
   end
@@ -169,10 +169,10 @@ Both hooks **fail open** on any unexpected condition (no context, network glitch
 | --- | --- | --- | --- | --- | --- |
 | `start` (local) | `127.0.0.1` | **on** (default) | `bypassPermissions` | `danger-full-access` | full: install deps + run tests |
 | `auth` | `127.0.0.1` | off | `acceptEdits` | `workspace-write` | edits-only, no network |
-| `vps` | `0.0.0.0` | off | `acceptEdits` | `workspace-write` | edits-only — *plus* the Docker container + Tailscale are the hard jail |
+| `vps` | `0.0.0.0` | off | `acceptEdits` | `workspace-write` | edits-only — *plus* the Tailscale-private host is the hard boundary |
 | `portable` | `0.0.0.0` | off | `acceptEdits` | `workspace-write` | edits-only |
 
-Defense-in-depth: prod modes already run inside Docker + Tailscale (the container is the real jail); the CLI stays restricted on top. Two more agent-spawn protections:
+Defense-in-depth: prod modes already run on a private host behind Tailscale (the tailnet-only host is the real boundary); the CLI stays restricted on top. Two more agent-spawn protections:
 
 - **Vanilla agents** — agents run independent of the operator's personal `~/.claude` hooks/plugins via a `--settings {disableAllHooks:true}` overlay (or a clean `CLAUDE_CONFIG_DIR` carrying only Constella's lock/guard hooks). Auth stays intact (the operator's credentials are copied in).
 - **No shell injection via model id** — `safeModel()` / `safeModelSlash()` validate the model string (which originates from agent-writable `Agent.md` frontmatter) against a strict charset before it reaches argv on a `shell: true` spawn, so `sonnet"; rm -rf ~` can't be re-parsed by the shell. Git/`gh` calls use `shell: false` so branch/message/path args are passed literally.

package/docs/en/START_MODE.md

@@ -258,7 +258,7 @@ A local install trades network hardening for local convenience — safe precisel
 - **Authentication always on.** A real signup-then-login gate guards every session — there is no auto-login and no predictable credential. The single operator is whoever completes the first-run signup.
 - **Real auth secret persisted.** A real `BETTER_AUTH_SECRET` is generated to `<HOME>/.env` (`chmod 600`) so sessions aren't forgeable; cookies are non-`Secure` only because the local transport is plain `http`.
 - **Full-access agents are local-only.** `bypassPermissions` lets agents run shell, but the workspace is still an FS jail (`safe()` lexical + symlink checks), and the guard/lock hooks still apply. Set `CONSTELLA_AGENT_FULL_ACCESS=0` to re-jail.
-- **Do not port-forward a local install.** If you need remote access, use [VPS](./VPS_MODE.md) (Tailscale + Docker) — never expose the loopback install to a network.
+- **Do not port-forward a local install.** If you need remote access, use [VPS](./VPS_MODE.md) (Tailscale, native) — never expose the loopback install to a network.
 
 ---
 

package/docs/en/TELEGRAM.md

@@ -231,7 +231,7 @@ A message with neither text nor any saved attachment is dropped.
 /approve                     → queue tasks
 /start_execution             → approve + 24/7 ON
 /pause   /resume             → flip 24/7
-/reject use Stripe not PayPal→ send plan back with a reason
+/reject use a different payment provider → send plan back with a reason
 /cancel  /archive            → stop / park the active goal
 /kb how does auth work?      → ask the Knowledge Base
 just talk normally           → chat with the CEO (Ada)

package/docs/en/TROUBLESHOOTING.md

@@ -171,7 +171,7 @@ Each diamond is a place a real symptom appears. The table in [§7](#7-symptom--c
 | Fresh install shows the **Sign in** screen and login fails with `User not found` | A **stale `~/.constella`** from a previous install. The runtime root persists across installs by design; its `<HOME>/.env` still has `CONSTELLA_OPERATOR_PW_SET=1` (forces the login screen) while its DB has a different / no operator. `operator@constella.dev` is only the **dev** seed — a real fresh install has no account. | Use the **Sign up** screen to create the first operator. If it's stuck on Sign in, you're reading old data: remove or rename `~/.constella` (back up first — it holds the DB, secrets, workspaces), or set `CONSTELLA_HOME` to a fresh dir, then relaunch → signup. |
 | better-auth throws on a default secret | No real `BETTER_AUTH_SECRET` | The launcher generates + persists one in `<HOME>/.env` (`chmod 600`) for **every** install target (auth is universal). If you cleared `.env`, just relaunch — it regenerates. |
 | Vault can't decrypt provider keys / Telegram token | `CONSTELLA_VAULT_KEY` changed or missing | The vault is AES-256-GCM keyed by `CONSTELLA_VAULT_KEY`. **Changing it orphans existing ciphertext.** Restore the original key from `<HOME>/.env`, or re-enter the secrets. |
-| VPS unreachable over the tailnet | Bound `0.0.0.0` but Tailscale/Docker not wired | VPS mode binds `0.0.0.0` for the tailnet and runs in Docker. Verify the container + Tailscale; the worker still talks to the server on loopback inside the container. |
+| VPS unreachable over the tailnet | Bound `0.0.0.0` but Tailscale not wired | VPS mode binds `0.0.0.0` for the tailnet and runs natively on the host. Verify the systemd service + Tailscale; the worker talks to the server on loopback. |
 
 ### 7.8 Portable & disk space 🪐
 

package/docs/en/VPS_MODE.md

@@ -75,7 +75,7 @@ flowchart TD
 
 ### Native on the host
 
-There is **no container**. The published `constellai` npm package (the compiled, prebuilt `.next`) is installed globally with `npm i -g` — there is **no source build**, because the public tree ships no `src/`. The `constella --vps` process runs directly under the host user. Tailscale runs on the **host**, so the host itself is the tailnet node; the web server's `0.0.0.0` bind is reachable **only at the host's Tailscale IP** as long as port 3000 has no public route (tailnet + firewall). Pin a version any time with `npm install -g constellai@<version>`.
+There is **no container**. The published `constellai` npm package (the compiled, prebuilt `.next`) is installed globally with `npm i -g` — there is **no source build**, because the npm package ships the prebuilt `.next`. The `constella --vps` process runs directly under the host user. Tailscale runs on the **host**, so the host itself is the tailnet node; the web server's `0.0.0.0` bind is reachable **only at the host's Tailscale IP** as long as port 3000 has no public route (tailnet + firewall). Pin a version any time with `npm install -g constellai@<version>`.
 
 ### Runtime root in the home directory
 
@@ -211,7 +211,7 @@ It runs `tailscale up` to join the host (using your tailnet account / auth flow
 
 ### 2. Provision a VPS
 
-A fresh **Ubuntu Server** (24.04 / 26.04 LTS) is the assumed target. You don't need to clone the repo for the managed path — the installer pulls `constellai` from npm. If you prefer to run the bootstrap from a checkout, get the product tree (it carries `scripts/vps-install.sh`):
+A fresh **Ubuntu Server** (24.04 / 26.04 LTS) is the assumed target. You don't need to clone the repo for the managed path — the installer pulls `constellai` from npm. If you prefer to run the bootstrap from a checkout, get the repo (it carries `scripts/vps-install.sh`):
 
 ```bash
 apt-get update && apt-get install -y git      # if git is missing

package/docs/pt/AI_ARCHITECTURE.md

@@ -143,7 +143,7 @@ Quando esse dir limpo está ativo, `claudeSettingsArgs()` retorna `[]` (o dir j
 | `start` (dev local) | `true` | `bypassPermissions` (instala + roda testes) | `danger-full-access` |
 | `auth` / `vps` / `portable` (prod) | `false` | `acceptEdits` (só edições, sem rede/exec) | `workspace-write` (sem rede) |
 
-> Em prod já roda dentro de Docker + Tailscale (o container é a jaula dura). A CLI fica restrita por cima para defesa em profundidade.
+> Em prod já roda num host privado atrás do Tailscale (o host só-tailnet é a fronteira dura). A CLI fica restrita por cima para defesa em profundidade.
 
 ### Pesquisa na web 🌠
 
@@ -339,7 +339,7 @@ opencode auth list        # detectCliAuth("opencode")
 - **shell:false para git/gh** — executáveis reais rodam com `shell: false` para que args de branch/mensagem/caminho influenciados pelo cliente não possam ser re-parseados por um shell.
 - **Hooks vanilla** — `disableAllHooks` mantém os plugins/hooks do operador fora das execuções dos agentes (isolamento de voz + comportamento).
 - **Command guard** — `bin/guard-hook.mjs` (padrão LIGADO) bloqueia shell catastrófico (`rm -rf /`, force-push, `mkfs`, fork-bomb).
-- **Jaula de permissão em prod** — `acceptEdits` (sem rede/exec arbitrário) por cima de Docker + Tailscale.
+- **Jaula de permissão em prod** — `acceptEdits` (sem rede/exec arbitrário) por cima do host privado no Tailscale.
 - **Scrub de segredos** — respostas de chat passam por `scrubSecrets` antes de serem armazenadas / mostradas / enviadas ao Telegram.
 - **Endurecimento contra prompt-injection** — cláusulas de Telegram + arquivos anexados marcam a entrada do operador como DADO, nunca instruções.
 

package/docs/pt/CHAT_COMMANDS.md

@@ -212,7 +212,7 @@ Todo comando reconhecido por `runSlashCommand`, agrupado por categoria. "Respond
 /graph SPEC-01
 /reindex
 /curate
-/new-goal a billing page with Stripe checkout
+/new-goal a billing page with payment-provider checkout
 /new-work add 2FA to the login screen
 /generate-plan migrate the database to Postgres
 /approve

package/docs/pt/CONFIGURATION.md

@@ -314,7 +314,7 @@ node scripts/mcp-server.mjs
 - `src/lib/scrub.ts` remove `CONSTELLA_VAULT_KEY`, `BETTER_AUTH_SECRET` e `CONSTELLA_WORKER_SECRET` antes da ingestão de KB, do Telegram e dos logs.
 - O worker aplica um **guard de SSRF apenas-loopback** em `CONSTELLA_BASE_URL`.
 - `process.env` sempre sobrescreve o arquivo `.env` — operadores controlam a configuração via shell/Docker/systemd, não via um arquivo gravável por atacante.
-- As permissões dos agentes degradam com segurança: acesso total só com `--start` (sua própria máquina); `--vps`/`--portable` ficam jaulados (Docker + Tailscale como jaula dura). A autenticação (e-mail + senha) é exigida em todo destino. Veja [SECURITY](./SECURITY.md).
+- As permissões dos agentes degradam com segurança: acesso total só com `--start` (sua própria máquina); `--vps`/`--portable` ficam jaulados (o host só-tailnet como fronteira dura). A autenticação (e-mail + senha) é exigida em todo destino. Veja [SECURITY](./SECURITY.md).
 
 ---
 

package/docs/pt/DESIGN.md

@@ -98,7 +98,7 @@ O painel **Docs** renderiza a documentação que a Grace escreve em markdown: `d
 ## RAG & seleção de skills 🌌
 
 A Grace não lê uma lista chapada de skills. Ela **extrai palavras-chave** do brief, missão, objetivo, mock anexado e da
-sua mensagem, **expande** por um léxico de domínio + estilo (hotel → reserva / hospitalidade / quartos; "Apple/iOS" →
+sua mensagem, **expande** por um léxico de domínio + estilo (hotel → reserva / hospitalidade / quartos; "native mobile" →
 glassmorphism / microinterações / tipografia premium) e **rankeia as skills seedadas** por nome / tags / descrição — e
 lê as mais relevantes primeiro. Ciente de domínio e estilo, não genérica.
 

package/docs/pt/FAQ.md

@@ -114,7 +114,7 @@ O diretório do workspace é a **fonte da verdade** (`src/lib/fs-workspace.ts`);
 Sim — dois padrões suportados, mais uma ressalva:
 
 - **Portable** (`--portable`): a raiz de runtime fica num **pendrive USB** montado como raiz, carregado entre máquinas. Requer `>=32GB` livres (fatal abaixo disso); `>=32GB` está ok. Bind em `0.0.0.0`. Login (e-mail + senha) é obrigatório — como em todos.
-- **VPS** (`--vps`): o Constella roda em Docker num servidor e você o acessa pela sua **tailnet Tailscale**. Bind em `0.0.0.0`. Login (e-mail + senha) obrigatório, igual a todo destino.
+- **VPS** (`--vps`): o Constella roda nativamente num servidor (npm + systemd, sem Docker) e você o acessa pela sua **tailnet Tailscale**. Bind em `0.0.0.0`. Login (e-mail + senha) obrigatório, igual a todo destino.
 
 Ressalva: as credenciais de assinatura da CLI (`~/.claude/.credentials.json`) ficam no host que roda os agentes. O Constella copia as credenciais Claude do operador para um diretório de config limpo por agente para que os agentes permaneçam logados (veja Q8), mas a **máquina host** ainda precisa de um login de CLI válido. O modo portable carrega os dados do Constella, não necessariamente a autenticação de cada CLI.
 
@@ -131,14 +131,14 @@ A flag de execução é um **destino de instalação** (`src/lib/run-mode.ts`),
 | Destino de instalação | Flag | Bind | Melhor para |
 | --- | --- | --- | --- |
 | Local (padrão) | `--start` | `127.0.0.1` | Uso local solo na sua própria máquina; agentes têm **acesso total** (instalar deps, rodar testes) |
-| VPS | `--vps` | `0.0.0.0` | Um servidor compartilhado via Tailscale, roda em Docker; agentes **enjaulados** apenas a edições |
+| VPS | `--vps` | `0.0.0.0` | Um servidor compartilhado via Tailscale (nativo, sem Docker); agentes **enjaulados** apenas a edições |
 | USB | `--portable` | `0.0.0.0` | Um USB que você carrega entre máquinas; agentes **enjaulados** |
 
 ```mermaid
 flowchart TD
   Q{"Onde vai rodar?"}
   Q -->|Minha própria máquina| START["--start local, agente com acesso total"]
-  Q -->|Um servidor que acesso remotamente| VPS["--vps Docker + Tailscale"]
+  Q -->|Um servidor que acesso remotamente| VPS["--vps nativo + Tailscale"]
   Q -->|Um USB que carrego| PORT["--portable"]
   START --> AUTH["todos os destinos: cadastro depois login<br/>e-mail + senha"]
   VPS --> AUTH

package/docs/pt/GOALS_SPECS_ISSUES.md

@@ -230,7 +230,7 @@ stateDiagram-v2
 **Novo trabalho a partir de uma DM** (tratado por `planFromConversationFor` → `generatePlanFor`):
 
 ```
-@ada construa um painel de cobrança com Stripe e exportação CSV
+@ada construa um painel de cobrança com um provedor de pagamento e exportação CSV
 ```
 
 **Aprovar via slash command** ([CHAT_COMMANDS](./CHAT_COMMANDS.md)):

package/docs/pt/MCP.md

@@ -164,7 +164,7 @@ O servidor MCP conversa com um servidor ativo em `CONSTELLA_BASE_URL` (padrão `
   "mcpServers": {
     "constella": {
       "command": "node",
-      "args": ["C:/Users/Usuario/Documents/constella/scripts/mcp-server.mjs"],
+      "args": ["/path/to/constella/scripts/mcp-server.mjs"],
       "env": {
         "CONSTELLA_PAT": "cn_seu_token_write_aqui",
         "CONSTELLA_BASE_URL": "http://localhost:3000"

package/docs/pt/PLUGINS.md

@@ -179,7 +179,7 @@ Dois esclarecimentos cruciais:
 ### "Instalar" um plugin placeholder (PARCIAL)
 
 1. Clique em **Install from URL** na topbar.
-2. O `window.prompt` do navegador pede uma URL ou nome (texto placeholder: `github.com/acme/slack-bridge`).
+2. O `window.prompt` do navegador pede uma URL ou nome (texto placeholder: `github.com/acme/chat-bridge`).
 3. `installPlugin(url.trim())` insere uma linha não-nativa, `enabled: true`, `description: "Installed from URL"`.
 4. Nada é baixado nem cabeado. A linha é apenas um marcador — **isto é um mock** (veja [Estados possíveis](#estados-possíveis-)).
 
@@ -208,7 +208,7 @@ await togglePlugin(githubPluginId, false);
 ```ts
 import { installPlugin } from "@/server/actions/plugin-actions";
 
-const res = await installPlugin("github.com/acme/slack-bridge");
+const res = await installPlugin("github.com/acme/chat-bridge");
 // res => { ok: true }
 // Uma linha não-nativa aparece em /plugins, enabled, descrição "Installed from URL".
 // Nenhum código de bridge roda — é um marcador de catálogo.

package/docs/pt/PORTABLE_MODE.md

@@ -347,7 +347,7 @@ $ npx constellai --portable
 
 - **Update** ([UPDATE](./UPDATE.md)) — `detectRunContext()` retorna `"portable"`; `startUpdate()` **não** roda automaticamente no portátil. Faz backup de `.env` + db em `<USB>/.constella/backups/<timestamp>/`, depois retorna o comando e *"Portable: ensure free space, back up the drive, then run: `npm install -g constellai@latest`"* com `needsRestart: true`.
 - **Modelos locais / RAG** ([MODELS](./MODELS.md), [MEMORY_RAG](./MEMORY_RAG.md)) — modelos GGUF e servidores de embed/chat rodam a partir do runtime root no drive; o mínimo de 32 GB dá boot, mas os modelos locais são o motivo para levar um drive maior.
-- **VPS** ([VPS_MODE](./VPS_MODE.md)) — compartilha o bind em `0.0.0.0`; difere por o VPS rodar em Docker sobre uma tailnet, enquanto o portátil roda a partir de um drive.
+- **VPS** ([VPS_MODE](./VPS_MODE.md)) — compartilha o bind em `0.0.0.0`; difere por o VPS rodar nativamente no host sobre uma tailnet, enquanto o portátil roda a partir de um drive.
 - **Configuração** ([CONFIGURATION](./CONFIGURATION.md)) — `CONSTELLA_HOME`, `CONSTELLA_RUN_MODE`, `DATABASE_URL` e as variáveis de env de segredo estão documentadas lá.
 
 ---

package/docs/pt/PUBLISHING.md

@@ -4,9 +4,9 @@
 
 ![](../assets/divider-orbit.svg)
 
-Publicar é como a nave-mãe deixa o estaleiro. Dois lançamentos acontecem, em duas direções: o **tarball do npm** leva o *runtime compilado* aos usuários finais, e o **espelho público no Git** leva a *árvore do produto* (docs, launcher, migrações — sem código-fonte) para `github.com/gabriel7silva/constella`. A árvore privada de desenvolvimento permanece em casa, em órbita, no remoto `dev`. ✦
+Publicar é como a nave-mãe deixa o estaleiro. Dois lançamentos acontecem, em duas direções: o **tarball do npm** leva o *runtime compilado* aos usuários finais, e o repositório público no Git leva o *código-fonte aberto completo* (`src/`, docs, launcher, migrações) para `github.com/gabriel7silva/constella`. ✦
 
-> **Resumo** — Usuários finais recebem um runtime compilado e minificado, **nunca o `src/`**. O `npm publish` envia o `.next` pré-compilado; `scripts/publish-public.mjs --push` espelha uma árvore limpa, escaneada contra segredos e sem código-fonte para o repositório Git público. Ambos os canais se recusam a publicar segredos.
+> **Resumo** — Usuários finais recebem pelo npm um runtime compilado e minificado, **nunca o `src/`** (sem etapa de build). O `npm publish` envia o `.next` pré-compilado; `scripts/publish-public.mjs --push` espelha o código-fonte aberto para o repositório Git público, escaneado contra segredos. Ambos os canais se recusam a publicar segredos.
 
 ---
 
@@ -48,7 +48,7 @@ A Constella distribui por **dois canais** que compartilham um princípio: *publi
 
 1. **Canal npm** — `npm publish` envia o runtime como um tarball. A allowlist `files` no `package.json` seleciona exatamente o que viaja; `prepublishOnly` valida a árvore; `prepack` (`trim-next.mjs`) remove os artefatos de dev do `.next`, de modo que os usuários finais recebam apenas o runtime de produção.
 2. **Canal Git** — `scripts/publish-public.mjs` constrói uma árvore filtrada em um índice git *temporário* (HEAD menos `src/`/testes, mais as migrações geradas em `drizzle/`), escaneia contra segredos exatamente esse conjunto e faz **force-push** dele como um commit-raiz novo para o remoto `public`. O `.next` compilado **não** viaja pelo git — ele chega aos usuários pelo tarball do npm.
-3. **Repositório duplo** — o remoto privado `dev` (`constella-Dev`) guarda todo o histórico do código-fonte; o remoto `public` (`constella`) é um espelho limpo e descartável, não um histórico compartilhado.
+3. **Repositório público** — o remoto `public` (`constella`) é o lar do código-fonte aberto; o tarball do npm é publicado separadamente, com o `.next` compilado.
 
 > Nenhum dos canais carrega o `src/`. O esquema chega aos usuários como SQL gerado em `drizzle/`, aplicado por `drizzle-kit migrate`. Veja [INSTALLATION](./INSTALLATION.md).
 
@@ -186,8 +186,7 @@ O `publish-public.mjs` carrega um espelho inline do scanner do repositório. Ele
 
 | Remoto | Repositório | Contém | Histórico |
 | --- | --- | --- | --- |
-| `dev` | `gabriel7silva/constella-Dev` | Árvore de fonte privada completa (`src/`, testes, e2e, histórico) | Real, preservado |
-| `public` | `gabriel7silva/constella` | Apenas produto (docs, `bin/`, `drizzle/`, `skills/`, configs) | Descartável — sobrescrito por force-push |
+| `public` | `gabriel7silva/constella` | Código-fonte aberto completo (`src/`, docs, `bin/`, `drizzle/`, `skills/`, configs) | Open source |
 
 O espelho público **não** é um alvo de colaboração com histórico compartilhado. Cada `--push` escreve um commit-raiz novo e sobrescreve o `main` à força. O desenvolvimento acontece contra `dev`; o tarball do npm é publicado separadamente de qualquer push git.
 
@@ -220,7 +219,7 @@ tar -tf constellai-0.1.0.tgz | sort   # inspecione o que seria enviado — confi
 ```bash
 # Simulação — gera migrações se necessário, calcula o conjunto, escaneia segredos, imprime a contagem:
 node scripts/publish-public.mjs
-#   ✓ Clean: <N> files to publish (no src/, no secrets). Migrations: <M> file(s).
+#   ✓ Clean: <N> files to publish (full source, no secrets). Migrations: <M> file(s).
 
 # Push — constrói a árvore filtrada em um índice temp e faz force-push para o public main:
 node scripts/publish-public.mjs --push
@@ -243,7 +242,7 @@ O `clean-repo.mjs` é idempotente e conservador: ele só apaga um conjunto conhe
 
 ```text
 $ node scripts/publish-public.mjs
-✓ Clean: 412 files to publish (no src/, no secrets). Migrations: 7 file(s).
+✓ Clean: 1712 files to publish (full source, no secrets). Migrations: 7 file(s).
 
 Dry run. To publish the clean compiled tree to the public repo, run:
   node scripts/publish-public.mjs --push

package/docs/pt/README.md

@@ -28,7 +28,7 @@ A autenticação é sempre exigida (e-mail + senha), idêntica em todos — a fl
 | Doc | O que cobre |
 |-----|-------------|
 | [Start (local)](START_MODE.md) | `constella --start`, escuta em `127.0.0.1` — a instalação local padrão |
-| [VPS](VPS_MODE.md) | `constella --vps`, escuta em `0.0.0.0` sobre uma tailnet Tailscale, Docker |
+| [VPS](VPS_MODE.md) | `constella --vps`, escuta em `0.0.0.0` sobre uma tailnet Tailscale (nativo, sem Docker) |
 | [Portable (USB)](PORTABLE_MODE.md) | `constella --portable`, roda a partir de um pen-drive, escuta em `0.0.0.0` |
 
 ## 🛰️ Arquitetura

package/docs/pt/SECURITY.md

@@ -26,7 +26,7 @@ A Constella empilha controles independentes para que nenhuma falha isolada seja
 ```mermaid
 flowchart TB
   subgraph Edge["🛰️ Borda de rede"]
-    A1["Bind por run-mode: start/auth = 127.0.0.1 · vps/portable = 0.0.0.0 + Tailscale/Docker"]
+    A1["Bind por run-mode: start/auth = 127.0.0.1 · vps/portable = 0.0.0.0 + Tailscale"]
     A2["Barreira de sessão do better-auth (e-mail+senha · 2FA TOTP · passkeys WebAuthn)"]
     A3["Endpoints do worker: x-worker-secret, fail CLOSED"]
   end
@@ -169,10 +169,10 @@ Ambos os hooks **falham abertos** em qualquer condição inesperada (sem context
 | --- | --- | --- | --- | --- | --- |
 | `start` (local) | `127.0.0.1` | **ligado** (padrão) | `bypassPermissions` | `danger-full-access` | completo: instala deps + roda testes |
 | `auth` | `127.0.0.1` | desligado | `acceptEdits` | `workspace-write` | só edições, sem rede |
-| `vps` | `0.0.0.0` | desligado | `acceptEdits` | `workspace-write` | só edições — *além* do container Docker + Tailscale serem a cela dura |
+| `vps` | `0.0.0.0` | desligado | `acceptEdits` | `workspace-write` | só edições — *além* do host privado no Tailscale ser a fronteira dura |
 | `portable` | `0.0.0.0` | desligado | `acceptEdits` | `workspace-write` | só edições |
 
-Defesa em profundidade: modos de prod já rodam dentro de Docker + Tailscale (o container é a cela real); o CLI fica restrito por cima. Mais duas proteções no spawn do agente:
+Defesa em profundidade: modos de prod já rodam num host privado atrás do Tailscale (o host só-tailnet é a fronteira real); o CLI fica restrito por cima. Mais duas proteções no spawn do agente:
 
 - **Agentes vanilla** — agentes rodam independentes dos hooks/plugins pessoais do `~/.claude` do operador via um overlay `--settings {disableAllHooks:true}` (ou um `CLAUDE_CONFIG_DIR` limpo carregando apenas os hooks de lock/guard da Constella). A auth permanece intacta (as credenciais do operador são copiadas).
 - **Sem injeção de shell via id de modelo** — `safeModel()` / `safeModelSlash()` validam a string de modelo (que se origina do frontmatter de `Agent.md`, gravável pelo agente) contra um charset estrito antes de chegar ao argv num spawn `shell: true`, então `sonnet"; rm -rf ~` não pode ser re-interpretado pelo shell. Chamadas de git/`gh` usam `shell: false` para que args de branch/mensagem/path sejam passados literalmente.

package/docs/pt/START_MODE.md

@@ -258,7 +258,7 @@ Uma instalação local troca o endurecimento de rede por conveniência local —
 - **Autenticação sempre ligada.** Uma barreira real de cadastro-depois-login guarda cada sessão — não há auto-login e não há credencial previsível. O operador único é quem completa o cadastro na primeira execução.
 - **Segredo de auth real persistido.** Um `BETTER_AUTH_SECRET` real é gerado em `<HOME>/.env` (`chmod 600`) para que as sessões não sejam forjáveis; os cookies são não-`Secure` apenas porque o transporte local é `http` puro.
 - **Agentes com acesso total são apenas locais.** `bypassPermissions` deixa os agentes rodarem shell, mas o workspace ainda é uma jaula de FS (`safe()` com checagens léxicas + de symlink), e os hooks de guarda/lock continuam valendo. Defina `CONSTELLA_AGENT_FULL_ACCESS=0` para reaprisionar.
-- **Não faça port-forward de uma instalação local.** Se precisar de acesso remoto, use [VPS](./VPS_MODE.md) (Tailscale + Docker) — nunca exponha a instalação de loopback a uma rede.
+- **Não faça port-forward de uma instalação local.** Se precisar de acesso remoto, use [VPS](./VPS_MODE.md) (Tailscale, nativo) — nunca exponha a instalação de loopback a uma rede.
 
 ---
 

package/docs/pt/TELEGRAM.md

@@ -231,7 +231,7 @@ Uma mensagem sem texto e sem nenhum anexo salvo é descartada.
 /approve                     → enfileira as tasks
 /start_execution             → aprova + 24/7 LIGADO
 /pause   /resume             → liga/desliga o 24/7
-/reject use Stripe e não PayPal→ devolve o plano com um motivo
+/reject use um provedor de pagamento diferente → devolve o plano com um motivo
 /cancel  /archive            → para / arquiva o goal ativo
 /kb como funciona a auth?    → pergunta à Base de Conhecimento
 só conversar normalmente     → fala com a CEO (Ada)

package/docs/pt/TROUBLESHOOTING.md

@@ -171,7 +171,7 @@ Cada losango é um lugar onde um sintoma real aparece. A tabela em [§7](#7-sint
 | Install fresco mostra a tela **Sign in** e o login falha com `User not found` | Um **`~/.constella` velho** de um install anterior. O runtime root persiste entre installs de propósito; o `<HOME>/.env` dele ainda tem `CONSTELLA_OPERATOR_PW_SET=1` (força a tela de login) enquanto o DB tem um operator diferente / nenhum. `operator@constella.dev` é só o seed do **dev** — um install fresco de verdade não tem conta. | Use a tela **Sign up** pra criar o primeiro operator. Se travar no Sign in, você tá lendo dado velho: remova ou renomeie `~/.constella` (faça backup — tem DB, segredos, workspaces), ou aponte `CONSTELLA_HOME` pra um dir novo, e reinicie → signup. |
 | better-auth lança erro com segredo padrão | Sem `BETTER_AUTH_SECRET` real | O launcher gera + persiste um em `<HOME>/.env` (`chmod 600`) para **todo** destino de instalação (a autenticação é universal). Se você limpou o `.env`, basta reiniciar — ele regenera. |
 | O vault não decifra as chaves de provedor / token do Telegram | `CONSTELLA_VAULT_KEY` mudou ou sumiu | O vault é AES-256-GCM com chave `CONSTELLA_VAULT_KEY`. **Trocar a chave orfana o texto cifrado existente.** Restaure a chave original de `<HOME>/.env`, ou re-insira os segredos. |
-| VPS inacessível pela tailnet | Bind em `0.0.0.0` mas Tailscale/Docker não conectados | O modo VPS faz bind em `0.0.0.0` para a tailnet e roda em Docker. Verifique o contêiner + Tailscale; o worker ainda fala com o servidor por loopback dentro do contêiner. |
+| VPS inacessível pela tailnet | Bind em `0.0.0.0` mas Tailscale não conectado | O modo VPS faz bind em `0.0.0.0` para a tailnet e roda nativamente no host sob systemd. Verifique o serviço + Tailscale; o worker ainda fala com o servidor por loopback no host. |
 
 ### 7.8 Portable & espaço em disco 🪐
 
@@ -231,7 +231,7 @@ Se um sintoma estiver à esquerda, **espere um ciclo** antes de intervir — o s
 
 **C. Os agentes não fazem nada durante a noite.** Há logs de tick mas nenhum card de trabalho se move. O plano do goal existe mas **Run 24/7 está desligado** — `tickAll(auto:true)` o pula. Aprove o plano e habilite o Run 24/7.
 
-**D. O worker sai na hora num VPS.** Log: `✖ Refusing to send the worker secret to a non-loopback host`. Seu `CONSTELLA_BASE_URL` aponta para um hostname público. Ajuste-o para o loopback dentro do contêiner, ou `CONSTELLA_ALLOW_REMOTE_WORKER_BASE_URL=1` sobre `https://` se o remoto for mesmo a intenção.
+**D. O worker sai na hora num VPS.** Log: `✖ Refusing to send the worker secret to a non-loopback host`. Seu `CONSTELLA_BASE_URL` aponta para um hostname público. Ajuste-o para o loopback no host, ou `CONSTELLA_ALLOW_REMOTE_WORKER_BASE_URL=1` sobre `https://` se o remoto for mesmo a intenção.
 
 ---
 

package/docs/pt/VPS_MODE.md

@@ -75,7 +75,7 @@ flowchart TD
 
 ### Nativo no host
 
-**Não há contêiner.** O pacote npm publicado `constellai` (o `.next` compilado e pré-buildado) é instalado globalmente com `npm i -g` — **não há build de fonte**, porque a árvore pública não inclui `src/`. O processo `constella --vps` roda direto sob o usuário do host. O Tailscale roda no **host**, então o próprio host é o nó da tailnet; o bind `0.0.0.0` do servidor web fica acessível **apenas no IP do Tailscale do host** enquanto a porta 3000 não tiver rota pública (tailnet + firewall). Fixe uma versão a qualquer momento com `npm install -g constellai@<versão>`.
+**Não há contêiner.** O pacote npm publicado `constellai` (o `.next` compilado e pré-buildado) é instalado globalmente com `npm i -g` — **não há build de fonte**, porque o pacote npm já traz o `.next` pré-buildado. O processo `constella --vps` roda direto sob o usuário do host. O Tailscale roda no **host**, então o próprio host é o nó da tailnet; o bind `0.0.0.0` do servidor web fica acessível **apenas no IP do Tailscale do host** enquanto a porta 3000 não tiver rota pública (tailnet + firewall). Fixe uma versão a qualquer momento com `npm install -g constellai@<versão>`.
 
 ### Raiz de runtime no diretório home