gipity 1.1.1 → 1.1.3

package/README.md

@@ -2,13 +2,13 @@
 
 The full-stack platform tuned for AI agents.
 
-[Gipity](https://gipity.ai) is the platform: hosting, databases, file storage, deployment, workflows, code execution, and monitoring. Agent-tuned from idea to deploy. Use standalone, or pair with Claude Code to give your local agent cloud superpowers. Any model, any infra, always your code.
+[Gipity](https://gipity.ai) is the platform: hosting, databases, file storage, deployment, workflows, code execution, and monitoring. Agent-tuned from idea to deploy. Use standalone, or pair with your coding agent - Claude Code, Codex, or Grok - to give it cloud superpowers. Any model, any infra, always your code.
 
-This CLI connects [Claude Code](https://claude.ai/claude-code) to Gipity's cloud platform - databases, deployment, browser testing, image gen, and 50+ other capabilities your local agent doesn't have. It also syncs files so Claude Code and the Gipity web agent share the same project.
+This CLI connects your coding agent - [Claude Code](https://claude.ai/claude-code), Codex, or Grok - to Gipity's cloud platform: databases, deployment, browser testing, image gen, and 50+ other capabilities your local agent doesn't have. It also syncs files so your local agent and the Gipity web agent share the same project.
 
 ## Getting Started
 
-One line installs everything. It sets up Node 18+ (if you don't already have it) and the Gipity CLI, with no sudo required:
+**Step 1 - install.** One line installs everything. It sets up Node 18+ (if you don't already have it) and the Gipity CLI, with no sudo required:
 
 ```bash
 # macOS / Linux / WSL
@@ -18,13 +18,42 @@ curl -fsSL https://gipity.ai/install.sh | bash
 irm https://gipity.ai/install.ps1 | iex
 ```
 
-Then launch your coding agent wired into Gipity:
+**Step 2 - pick your path.** There are three, and they mix freely:
+
+| You want to... | Run |
+|----------------|-----|
+| Start building right now, from anywhere | `gipity build` |
+| Use your own workflow in your own directory | `gipity init`, then `claude` / `codex` / `grok` |
+| Drive this computer from gipity.ai (phone, browser) | `gipity connect` |
+
+### `gipity build` - start from anywhere
+
+One command does everything: logs you in (6-digit email code), lets you pick or create a project, lets you pick your coding agent (Claude Code, Codex, or Grok - it installs the agent if needed), and launches it with the whole Gipity stack wired up.
 
 ```bash
-gipity claude
+gipity build
 ```
 
-`gipity claude` walks you through login, project setup, and launches Claude Code. Using Codex, Gemini, or Cursor instead? Run `gipity init`.
+### `gipity init` - bring your own workflow
+
+Prefer launching your agent yourself? From any project directory:
+
+```bash
+gipity init
+claude        # or codex, or grok - whatever you use
+```
+
+`init` links the directory to a Gipity project, writes CLAUDE.md/AGENTS.md primers so your agent understands Gipity, and installs the Gipity skills + file-sync hooks into the agent CLIs found on your machine (Claude Code, Codex, Grok; Cursor and Gemini get primer files too).
+
+### `gipity connect` - drive it from the web
+
+Want to start chats from gipity.ai (including your phone) and have them run the coding agent on this computer? Connect it once:
+
+```bash
+gipity connect
+```
+
+It logs you in, pairs the machine, starts the Gipity relay in the background, and installs the login service so it survives reboots - then stops, without launching anything. From then on, open gipity.ai and start a chat to drive your agent here. Manage it with `gipity relay status` / `pause` / `resume` / `revoke`.
 
 ### Prefer npm
 
@@ -47,15 +76,7 @@ gipity update   # force an immediate update now
 
 To opt out: `export DISABLE_AUTOUPDATER=1` (matches Claude Code), or set `{ "autoUpdates": false }` in `~/.gipity/settings.json`. CI environments are auto-detected and skipped.
 
-## Quick Start
-
-One command. It walks you through login, project setup, and drops you into Claude Code.
-
-```bash
-gipity claude --dangerously-skip-permissions
-```
-
-That's it. You'll see:
+## What `gipity build` looks like
 
 ```
   Welcome to Gipity
@@ -72,16 +93,29 @@ That's it. You'll see:
     2. Create new project
 
   Choose (1-2): 2
-  Project name [project01]: cool-app
+  Project name [project-001]: cool-app
   Creating "cool-app"...
   Created.
 
-  Launching Claude Code...
+  Which coding agent?
+    1. Claude Code (Anthropic)
+    2. Codex (OpenAI)
+    3. Grok (xAI)
+
+  Launching Claude Code, powered by Gipity.
 ```
 
-If you're already logged in, it skips straight to project setup. If you already have a project in the current directory, it skips straight to launching Claude Code.
+If you're already logged in, it skips straight to the project picker. If you're already inside a Gipity project directory, it uses that project. Your last-used agent is the default next time.
+
+Projects live in `~/GipityProjects/{project-slug}/` - created automatically on first use. Any extra flags (like `--model opus`) pass straight through to the agent. Useful flags:
 
-Projects live in `~/GipityProjects/{project-slug}/` - created automatically on first use. Any extra flags (like `--dangerously-skip-permissions`, `--model opus`, etc.) get passed through to Claude.
+```bash
+gipity build --agent codex             # Skip the agent picker
+gipity build --new-project --name app  # Create a fresh project without the picker
+gipity build --project my-app          # Open a specific project
+gipity build --here                    # Use the current directory, not ~/GipityProjects/
+gipity build -p "add a contact form"   # Headless one-shot (no interactive session)
+```
 
 ### The manual way
 
@@ -92,26 +126,28 @@ gipity login --email you@example.com
 gipity login --code 123456
 cd my-project
 gipity init
-claude
+claude        # or codex, or grok
 ```
 
-## Claude Code Integration
+## Coding Agent Integration
+
+This is the good part. When you run `gipity init` (or `gipity build`) in a project, it wires two hooks into your agent (Claude Code, Codex, and Grok all get them):
 
-This is the good part. When you run `gipity init` in a project, it sets up two hooks in `.claude/settings.json`:
+**Auto-push** - Every time your agent writes or edits a file, it gets pushed to Gipity in the background. No extra steps.
 
-**Auto-push** - Every time Claude Code writes or edits a file, it gets pushed to Gipity in the background. No extra steps.
+**Auto-pull** - Before each turn, your agent pulls any changes that happened remotely (like if your Gipity agent built something via chat). It sees what changed and can pick up where things left off.
 
-**Auto-pull** - Before each turn, Claude Code pulls any changes that happened remotely (like if your Gipity agent built something via chat). Claude sees what changed and can pick up where things left off.
+That means your local agent and your Gipity agent share the same files, same project, same context. You get the best of both - hands-on coding locally, autonomous agent work on Gipity.
 
-That means Claude Code and your Gipity agent share the same files, same project, same context. You get the best of both - Claude Code for hands-on coding, Gipity for autonomous agent work.
+Sessions are also recorded to your Gipity project so you can watch them live at prompt.gipity.ai. Opt out per project with `gipity init --no-capture`.
 
 ### What gets set up
 
 ```
 .gipity.json          # Project config (which project, which agent)
 .gipity/              # Local sync state (gitignored)
-.claude/settings.json # Hooks for auto-push and auto-pull
-CLAUDE.md             # Gipity commands reference for Claude Code
+.claude/settings.json # Hooks for auto-push and auto-pull (per-agent equivalents for Codex/Grok)
+CLAUDE.md / AGENTS.md # Gipity commands reference for your agent
 ```
 
 ### Manual sync
@@ -128,9 +164,11 @@ gipity sync down     # Pull remote changes
 
 | Command | What it does |
 |---------|-------------|
-| `gipity claude` | Log in, pick a project, and launch Claude Code - all in one |
+| `gipity build` | Log in, pick a project, pick your coding agent, and launch it - all in one |
+| `gipity init` | Link this directory to a project and set up your coding agent |
+| `gipity connect` | Connect this computer to gipity.ai so the web CLI can drive it |
+| `gipity relay` | Manage the relay (status, pause, resume, revoke) |
 | `gipity login` | Authenticate with email + verification code |
-| `gipity init` | Set up a Gipity project and configure Claude Code |
 | `gipity status` | Show project, agent, and auth info |
 | `gipity sync` | Sync files between local and Gipity |
 | `gipity push <file>` | Push a single file |

package/dist/agents/claude-code.js

@@ -5,11 +5,6 @@ export const claudeCodeAdapter = {
     displayName: 'Claude Code',
     providerName: 'Anthropic',
     binary: 'claude',
-    models: [
-        { id: 'opus', label: 'Opus' },
-        { id: 'sonnet', label: 'Sonnet' },
-        { id: 'haiku', label: 'Haiku' },
-    ],
     buildInteractiveArgs({ resume, model }) {
         const args = [];
         if (model)

package/dist/agents/codex.js

@@ -4,10 +4,6 @@ export const codexAdapter = {
     displayName: 'Codex',
     providerName: 'OpenAI',
     binary: 'codex',
-    models: [
-        { id: 'gpt-5.1-codex', label: 'GPT-5.1 Codex' },
-        { id: 'gpt-5.1-codex-mini', label: 'GPT-5.1 Codex Mini' },
-    ],
     buildInteractiveArgs({ resume, model }) {
         const args = [];
         if (model)

package/dist/agents/grok.js

@@ -4,10 +4,6 @@ export const grokAdapter = {
     displayName: 'Grok',
     providerName: 'xAI',
     binary: 'grok',
-    models: [
-        { id: 'grok-4.5', label: 'Grok 4.5' },
-        { id: 'grok-code', label: 'Grok Code' },
-    ],
     buildInteractiveArgs({ resume, model }) {
         const args = [];
         if (model)

package/dist/api.js

@@ -56,8 +56,8 @@ async function bearerToken() {
 /** True when a long-lived agent API token (GIPITY_TOKEN) is in play. Such a token
  *  is static — it can't be refreshed — so the 401 self-heal path must skip it and
  *  the "run: gipity login" hint must not be shown (that's the wrong recovery for
- *  env-token callers). */
-function usingEnvToken() {
+ *  env-token callers). Exported so `gipity status` can name the auth source. */
+export function usingEnvToken() {
     return !!process.env.GIPITY_TOKEN?.trim();
 }
 // A transient 401 on a session token means the access token the server just saw
@@ -83,9 +83,12 @@ async function shouldRetryAfter401(status, retried) {
 /** Append a re-login hint to a 401 message for session users. A 401 that
  *  survived the refresh-and-retry is an unrecoverable session (the refresh token
  *  is gone too); env-token callers authenticate differently, so don't misdirect
- *  them. */
+ *  them. Names the headless path too — an unattended agent has no mailbox for
+ *  the emailed login code, and dead-ending there stranded whole runs (cli#137). */
 function with401Hint(status, message) {
-    return status === 401 && !usingEnvToken() ? `${message} — run: gipity login` : message;
+    return status === 401 && !usingEnvToken()
+        ? `${message} — run: gipity login (headless/CI: set GIPITY_TOKEN instead — gipity skill read agent-deploy)`
+        : message;
 }
 async function getHeaders() {
     return {

package/dist/catalog.js

@@ -0,0 +1,46 @@
+/**
+ * The `gipity add` catalog - template + kit keys with terse list hints.
+ *
+ * AUTO-GENERATED - do not edit directly.
+ * Source: platform/packages/shared/src/constants.ts (TEMPLATES/KITS cliHint fields)
+ * Run `just build-knowledge` to refresh.
+ */
+/** Visible starter templates (complete working demos). */
+export const STARTERS = [
+    { key: 'web-vision-cam', hint: 'fullscreen camera app with on-device vision (MediaPipe)' },
+    { key: 'object-spotter', hint: 'camera app that boxes, labels, and counts objects (YOLOX on-device)' },
+    { key: '2d-game', hint: '2D games with Phaser 3 - platformer, arcade, puzzle' },
+    { key: '3d-world', hint: 'playable 3D multiplayer rocket-launcher demo' },
+    { key: 'karaoke-captions', hint: 'audio + lyrics -> word-synced karaoke captions (GPU job)' },
+    { key: 'outreach-agent', hint: 'AI-run outreach funnel - import contacts, draft + auto-send staged emails' },
+    { key: 'paid-app', hint: 'storefront that charges real money - Stripe checkout, members area, billing' },
+    { key: 'notify-demo', hint: 'web-push demo - enable notifications, send a real ping' },
+];
+/** Visible blank-wiring templates. */
+export const BLANK = [
+    { key: 'web-simple', hint: 'static frontend-only site - pages, dashboards, simple games' },
+    { key: 'web-fullstack', hint: 'backend API + database wiring - frontend, functions, migrations; deploys green' },
+    { key: '3d-engine', hint: '3D multiplayer wiring - Three.js + Rapier + Gipity Realtime' },
+    { key: 'api', hint: 'pure API backend, no frontend - one example function + test' },
+];
+/** Hidden templates - installable by exact key, omitted from listings. */
+export const HIDDEN = [
+    { key: 'app-itsm', hint: 'IT service management / helpdesk / ticketing' },
+    { key: 'monitor', hint: 'account observability dashboard (auto-installed per account)' },
+];
+/** Kits - building blocks added into an existing app. */
+export const KITS = [
+    { key: 'realtime', hint: 'multiplayer / presence / shared state' },
+    { key: 'web-vision-mediapipe', hint: 'browser camera vision - gesture, pose, object detection' },
+    { key: 'web-vision-detect', hint: 'browser object detection - YOLOX, WebGPU/WASM, custom models' },
+    { key: 'chatbot', hint: 'drop-in chatbot - persona, guardrails, streaming responses' },
+    { key: 'audio-align', hint: 'audio + lyrics -> word-level timing JSON (GPU job)' },
+    { key: 'i18n', hint: 'multi-language web apps - language picker, RTL, translations' },
+    { key: 'records', hint: 'registry-driven data plane - generic CRUD, validation, search, audit spine' },
+    { key: 'views', hint: 'registry-driven UI over records - table, forms, kanban' },
+    { key: 'agent-api', hint: 'named API keys for agent/script writes through the records kit' },
+    { key: 'contacts', hint: 'multi-source contact layer - LinkedIn/Gmail import, dedupe with provenance' },
+    { key: 'stripe', hint: 'charge your users - Stripe checkout, subscriptions, brokered webhooks' },
+    { key: 'notify', hint: 'web push notifications - platform-owned keys, works on iOS home screen' },
+];
+//# sourceMappingURL=catalog.js.map

package/dist/commands/add.js

@@ -8,28 +8,15 @@ import { sync } from '../sync.js';
 import { success, muted, bold, warning, error as clrError } from '../colors.js';
 import { run } from '../helpers/index.js';
 import { createProgressReporter, withSpinner } from '../progress.js';
-const STARTERS = [
-    { key: 'web-vision-cam', hint: 'fullscreen camera app with on-device vision (MediaPipe)' },
-    { key: 'object-spotter', hint: 'camera app that boxes, labels, and counts objects (YOLOX on-device)' },
-    { key: '2d-game', hint: '2D games with Phaser 3 - platformer, arcade, puzzle' },
-    { key: '3d-world', hint: 'playable 3D multiplayer rocket-launcher demo' },
-    { key: 'karaoke-captions', hint: 'audio + lyrics -> word-synced karaoke captions (GPU job)' },
-];
-const BLANK = [
-    { key: 'web-simple', hint: 'static frontend-only site - pages, dashboards, simple games' },
-    { key: 'web-fullstack', hint: 'backend API + database wiring - frontend, functions, migrations; deploys green' },
-    { key: 'api', hint: 'pure API backend, no frontend - one example function + test' },
-    { key: '3d-engine', hint: '3D multiplayer wiring - Three.js + Rapier + Gipity Realtime' },
-];
-const HIDDEN = [{ key: 'app-itsm', hint: 'IT service management / helpdesk / ticketing' }];
-const KITS = [
-    { key: 'realtime', hint: 'multiplayer / presence / shared state' },
-    { key: 'web-vision-mediapipe', hint: 'browser camera vision - gesture, pose, object detection' },
-    { key: 'web-vision-detect', hint: 'browser object detection - YOLOX, WebGPU/WASM, custom models' },
-    { key: 'chatbot', hint: 'drop-in chatbot - persona, guardrails, streaming responses' },
-    { key: 'audio-align', hint: 'audio + lyrics -> word-level timing JSON (GPU job)' },
-    { key: 'i18n', hint: 'multi-language web apps - language picker, RTL, translations' },
-];
+// Catalog GENERATED from platform/packages/shared (TEMPLATES + KITS cliHint
+// fields) into src/catalog.ts by platform/scripts/build-knowledge.ts - the CLI
+// ships as a standalone npm package and can't depend on the private shared
+// workspace. The hand-mirrored copy that used to live here silently dropped
+// every new catalog entry; edit constants.ts + `just build-knowledge` instead.
+//
+// Templates install a whole app (blank wiring or a working starter demo).
+// Kits are reusable building blocks added into an existing app's src/packages/.
+import { STARTERS, BLANK, KITS } from '../catalog.js';
 // The catalog block, rendered once and reused by the full help output
 // (`gipity add` / `gipity add --help`) and the bare listing (`gipity add
 // --list`) so they can never drift. Three sections, one entry per line, keys

package/dist/commands/build.js

@@ -233,9 +233,9 @@ function suggestProjectName(existingSlugs) {
     return `project-${Date.now().toString(36).slice(-6)}`;
 }
 /** Both launch commands share one implementation: `gipity build` (the
- *  documented start-from-anywhere funnel: project picker + agent picker +
- *  model picker) and the hidden legacy `gipity claude` (identical behavior
- *  with the agent pinned to Claude and no agent/model questions - kept
+ *  documented start-from-anywhere funnel: project picker + agent picker) and
+ *  the hidden legacy `gipity claude` (identical behavior with the agent
+ *  pinned to Claude and no agent question - kept
  *  working forever because deployed relay daemons and the GUI installer
  *  invoke it, but no longer advertised anywhere). */
 function createLaunchCommand(name, cfg = {}) {
@@ -250,7 +250,7 @@ function createLaunchCommand(name, cfg = {}) {
         // Forwarded to the agent via the unknown-arg passthrough below (NOT in the
         // gipity strip lists). Declared here only so it shows up in --help — without
         // this, callers can't discover that the session model is selectable.
-        .option('--model <model>', 'Model for the session (e.g. opus, sonnet - or skip it to use your agent\'s own default)')
+        .option('--model <model>', 'Model for the session, passed straight to the agent (e.g. opus) - omit it and the agent uses its own default')
         .option('--bypass-approvals', 'Skip the agent\'s interactive tool approvals (headless runs; the relay daemon sets this)')
         .allowUnknownOption(true)
         .allowExcessArguments(true);
@@ -696,22 +696,18 @@ async function runLaunch(cmdName, cmdCfg, opts) {
             }
         }
         const adapter = getAdapter(agentKey);
-        // Model: an explicit --model (in the passthrough args) wins and skips
-        // the question. Interactive launches get the picker - option 1 is
-        // "Agent default", which passes NO model flag so the agent's own model
-        // memory stays authoritative. Headless runs never prompt. Only an
-        // interactive answer is remembered (a daemon dispatch or the legacy
-        // `gipity claude` shim must not clobber the user's picker memory).
-        const modelFlagGiven = rawArgs.some(a => a === '--model' || a.startsWith('--model='));
-        let pickedModel = null;
-        if (!nonInteractive && !modelFlagGiven && !cmdCfg.presetAgent) {
-            pickedModel = await pickModel(adapter, prefs.lastModel?.[adapter.key] ?? null);
-            writePrefs({ lastAgent: adapter.key, lastModel: { [adapter.key]: pickedModel } });
+        // We never ask about the model: an explicit `--model` passes straight
+        // through to the agent, and with no flag the agent's own default (and
+        // its own model memory) stays authoritative. Only an interactive pick
+        // is remembered (a daemon dispatch or the legacy `gipity claude` shim
+        // must not clobber the user's agent memory).
+        if (!nonInteractive && !cmdCfg.presetAgent) {
+            writePrefs({ lastAgent: adapter.key });
         }
         // ── Step 4: Launch the agent ───────────────────────────────────────
         if (adapter.key !== 'claude') {
             await launchNonClaudeAgent(adapter, {
-                cmdName, opts, rawArgs, nonInteractive, headlessOut, runStart, pickedModel,
+                cmdName, opts, rawArgs, nonInteractive, headlessOut, runStart,
             });
             return;
         }
@@ -873,12 +869,9 @@ async function runLaunch(cmdName, cmdCfg, opts) {
             }
         }
         else {
+            // Any `--model` the user passed is already in claudeArgs (passthrough);
+            // with no flag Claude picks its own default.
             allArgs = initialPrompt ? [initialPrompt, ...claudeArgs] : claudeArgs;
-            // Model from the interactive picker (an explicit --model flag skipped
-            // the picker and is already in claudeArgs; "Agent default" is null and
-            // deliberately passes nothing).
-            if (pickedModel)
-                allArgs.push('--model', pickedModel);
         }
         // Single-command headless flows (`--new-project` / `--project` with -p)
         // have no human to approve tool use - auto-bypass so Claude can actually
@@ -957,10 +950,11 @@ async function runLaunch(cmdName, cmdCfg, opts) {
         process.exit(1);
     }
 }
-// ─── Agent + model pickers ────────────────────────────────────────────────
+// ─── Agent picker ─────────────────────────────────────────────────────────
 // Same pick-a-number-or-hit-enter format as the project picker. The
-// enter-enter path must stay the visibly obvious one: default agent =
-// last-used (else Claude), default model = "Agent default".
+// enter-enter path must stay the visibly obvious one: the default agent is
+// the last-used one (else Claude). We deliberately don't ask about the model
+// - the agent's own default is always right and a curated list only rots.
 async function pickAgent(lastUsed) {
     const defaultKey = lastUsed && AGENT_KEYS.includes(lastUsed) ? lastUsed : 'claude';
     const defaultIdx = AGENT_ADAPTERS.findIndex(a => a.key === defaultKey) + 1;
@@ -983,22 +977,6 @@ async function pickAgent(lastUsed) {
     console.log('');
     return AGENT_ADAPTERS[choice - 1].key;
 }
-/** Returns the model id to pass via --model, or null for "Agent default"
- *  (no flag at all - the agent's own model memory stays authoritative). */
-async function pickModel(adapter, lastUsed) {
-    console.log(`  ${bold('Which model?')}\n`);
-    const lastIsModel = lastUsed && adapter.models.some(m => m.id === lastUsed);
-    const defaultIdx = lastIsModel ? adapter.models.findIndex(m => m.id === lastUsed) + 2 : 1;
-    console.log(`    ${bold('1.')} Agent default ${muted(defaultIdx === 1 ? '(recommended)' : '')}`);
-    adapter.models.forEach((m, i) => {
-        const note = m.id === lastUsed ? `  ${muted('(last used)')}` : '';
-        console.log(`    ${bold(`${i + 2}.`)} ${m.label}${note}`);
-    });
-    console.log('');
-    const choice = await pickOne('Choose', adapter.models.length + 1, defaultIdx);
-    console.log('');
-    return choice === 1 ? null : adapter.models[choice - 2].id;
-}
 // ─── Non-Claude agent launch (Codex, Grok) ────────────────────────────────
 // The Claude path above carries years of Claude-specific plumbing (plugin
 // install, folder trust, stream-json capture gating, -p context wrapping).
@@ -1008,7 +986,7 @@ async function pickModel(adapter, lastUsed) {
 // (there is no stream-json ingest path for them, so GIPITY_CAPTURE is never
 // turned off here).
 async function launchNonClaudeAgent(adapter, ctx) {
-    const { opts, rawArgs, nonInteractive, headlessOut, runStart, pickedModel } = ctx;
+    const { opts, rawArgs, nonInteractive, headlessOut, runStart } = ctx;
     // ── Binary ──────────────────────────────────────────────────────────────
     if (!binaryOnPath(adapter.binary)) {
         let installed = false;
@@ -1030,7 +1008,7 @@ async function launchNonClaudeAgent(adapter, ctx) {
     const valueFlags = ['--api-base', '--name', '--project', '--agent'];
     let message = null;
     let resume;
-    let model = pickedModel ?? undefined;
+    let model;
     const extras = [];
     for (let i = 0; i < rawArgs.length; i++) {
         const arg = rawArgs[i];

package/dist/commands/db.js

@@ -44,6 +44,11 @@ dbCommand
                     console.log(columns.map(c => String(row[c] ?? 'NULL')).join('\t'));
                 }
             }
+            // DML with RETURNING carries both rows and a count - the rows are the
+            // table above; still name how many rows the statement touched.
+            if (res.data.affectedRows !== undefined) {
+                console.log(`Affected rows: ${res.data.affectedRows}`);
+            }
         }
         else if (res.data.affectedRows !== undefined) {
             console.log(`Affected rows: ${res.data.affectedRows}`);
@@ -51,6 +56,11 @@ dbCommand
         else if (res.data.results) {
             console.log(JSON.stringify(res.data.results, null, 2));
         }
+        else {
+            // Unknown payload shape: print it raw rather than nothing - silence
+            // here reads as "the query returned no data", which is a lie.
+            console.log(JSON.stringify(res.data, null, 2));
+        }
     }
 }));
 dbCommand

package/dist/commands/deploy.js

@@ -146,6 +146,13 @@ export const deployCommand = new Command('deploy')
         // has to reconstruct the URL convention or guess a subdomain.
         if (d.url)
             console.log(`${muted('Live:')} ${brand(d.url)}`);
+        // Functions are served from the API host, NOT the static Live URL -
+        // for an API-only app the endpoint address IS the deliverable, so name
+        // it instead of leaving it to be inferred from a template comment.
+        if (d.phases?.some(p => p.name === 'functions')) {
+            console.log(`${muted('Functions:')} POST ${brand(`${config.apiBase}/api/${config.projectGuid}/fn/<name>`)}`);
+            console.log(muted('  (same address on dev and prod; names: gipity fn list; verify the public path: gipity fn call <name> --anon)'));
+        }
         await inspectAfter();
     }
 }));

package/dist/commands/fn.js

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import { get, post, del, publicPost } from '../api.js';
+import { getAuth } from '../auth.js';
 import { requireConfig } from '../config.js';
 import { error as clrError, bold, muted, success, warning } from '../colors.js';
 import { run, printList, emitField } from '../helpers/index.js';
@@ -17,6 +18,11 @@ fnCommand
         const line = `${bold(f.name)}  ${muted(`v${f.version}`)}  ${muted(f.auth_level)}  ${muted(`timeout=${f.timeout_ms}ms`)}`;
         return f.description ? `${line}\n${muted(f.description)}` : line;
     });
+    // The callable address is the deliverable for API-only apps - name it here
+    // rather than leaving it to be inferred from a template comment.
+    if (!opts.json && res.data.length > 0) {
+        console.log(muted(`Endpoint: POST ${config.apiBase}/api/${config.projectGuid}/fn/<name>  (same on dev and prod; public path: gipity fn call <name> --anon)`));
+    }
 }));
 fnCommand
     .command('logs <name>')
@@ -29,8 +35,15 @@ fnCommand
     printList(res.data, opts, 'No execution logs.', log => {
         const dur = log.duration_ms != null ? `${log.duration_ms}ms` : '?';
         const ts = new Date(log.created_at).toLocaleString();
-        const statusColor = log.status === 'success' ? success : log.status === 'error' ? clrError : muted;
+        // The runtime writes 'ok' | 'error' | 'limit_exceeded' - never 'success'
+        // (same dead value already fixed in `logs fn`).
+        const statusColor = log.status === 'ok' ? success : log.status === 'error' ? clrError : muted;
         let line = `${statusColor(log.status)}  ${dur}  ${muted(log.trigger_type || 'http')}  ${muted(ts)}`;
+        // Platform service calls made inside the invocation (notify, email,
+        // LLM, ...) - per-call outcomes live in `gipity logs app --type services`.
+        const svcCalls = log.limits_consumed?.max_service_calls;
+        if (svcCalls)
+            line += `  ${muted(`svc:${svcCalls}`)}`;
         if (log.error_message)
             line += `\n${clrError(`error: ${log.error_message}`)}`;
         // Captured console.log/warn/error output for this invocation.
@@ -69,6 +82,16 @@ fnCommand
     const raw = bodyArg || opts.data || '{}';
     const body = JSON.parse(raw);
     const path = `/api/${config.projectGuid}/fn/${encodeURIComponent(name)}`;
+    // Name the calling identity (stderr, so stdout stays parseable). Without
+    // this, a "test the anonymous path" call silently runs authenticated as
+    // the signed-in owner and the public path never gets exercised.
+    if (opts.anon) {
+        console.error(muted('Auth: anonymous visitor (the public path a signed-out user hits)'));
+    }
+    else {
+        const who = getAuth()?.email;
+        console.error(muted(`Auth: calling as ${who ?? 'your signed-in account'} (the owner persona; use --anon for the public visitor path)`));
+    }
     const res = opts.anon
         ? await callAnon(config.projectGuid, name, body)
         : await post(path, body);

package/dist/commands/logs.js

@@ -9,7 +9,20 @@ logsCommand
     .command('fn <name>')
     .description('Show function logs')
     .option('--limit <n>', 'Max entries', '20')
-    .option('--json', 'Output as JSON')
+    .option('--json', 'Output as JSON (top-level ARRAY of invocations, newest first)')
+    .addHelpText('after', `
+Each line: time, status (ok / error / limit_exceeded), duration, trigger, and
+svc:N when the invocation made N platform service calls (notify, email, LLM,
+image, ...). Captured console output is indented beneath its invocation.
+
+--json emits a top-level ARRAY (not an object) of invocation rows:
+  [{ id, status, duration_ms, trigger_type, error_message,
+     limits_consumed: { max_queries, max_service_calls, ... }, logs: [...], created_at }]
+
+To confirm an individual service call succeeded (and see provider, latency,
+and its own error message), use the per-call log instead:
+  $ gipity logs app --type services
+`)
     .action((name, opts) => run('Logs', async () => {
     const config = requireConfig();
     const limit = parseInt(opts.limit, 10) || 20;
@@ -32,8 +45,14 @@ logsCommand
         const statusColor = log.status === 'ok' ? success : log.status === 'error' ? clrError : warning;
         const status = statusColor(log.status.padEnd(8));
         const trigger = muted(log.trigger_type.padEnd(8));
+        // Service calls made inside the invocation (notify, email, LLM, ...) are
+        // otherwise invisible here - surface the count so "did my send happen?"
+        // doesn't require spelunking --json limits counters. Per-call outcomes
+        // live in `gipity logs app --type services`.
+        const svcCalls = log.limits_consumed?.max_service_calls;
+        const svc = svcCalls ? ` ${muted(`svc:${svcCalls}`)}` : '';
         const err = log.error_message ? `  ${clrError(`"${log.error_message}"`)}` : '';
-        console.log(`${muted(time)}  ${status} ${dur} ${trigger}${err}`);
+        console.log(`${muted(time)}  ${status} ${dur} ${trigger}${svc}${err}`);
         // Captured console.log/warn/error output for this invocation, indented
         // under its summary line. Empty for calls that printed nothing.
         for (const line of log.logs ?? []) {

package/dist/commands/page-eval.js

@@ -274,7 +274,8 @@ export function slowRenderMessage(fps, o) {
     return `${warning('⚠ Slow render:')} page painted at ${fps} fps. `
         + `Waiting on real time (setTimeout) advances animation/physics time far slower than it looks — `
         + `assertions after a wall-clock wait can report a false negative. `
-        + `Step the app's own loop deterministically instead (3D templates: ${bold('core.advance(seconds)')}).`;
+        + `Step the app's own loop deterministically instead (3D templates: ${bold('core.advance(seconds)')}; `
+        + `2D/Phaser template: ${bold("(await import('./js/config.js')).advance(seconds)")}).`;
 }
 /** Poll the async eval job until it finishes. Eval runs server-side as a
  *  short-lived job (so a long --wait can't trip the gateway idle timeout);
@@ -570,7 +571,10 @@ export const pageEvalCommand = new Command('eval')
             }));
             return;
         }
-        console.log(`${brand('Eval')} ${bold(d.url || url)}`);
+        // Context echo (which URL, which script) goes to stderr: the caller
+        // already knows what it sent, and keeping stdout = qualifiers + result
+        // means `2>/dev/null` (or any stdout capture) yields just the answer.
+        console.error(`${brand('Eval')} ${bold(d.url || url)}`);
         if (d.navigationIncomplete) {
             console.log(`${warning('⚠ Navigation incomplete:')} ${d.note || 'page did not reach full load'}`);
         }
@@ -597,7 +601,7 @@ export const pageEvalCommand = new Command('eval')
             console.log(`${muted('Camera:')} ${camera.name} ${muted('(played as the webcam feed; getUserMedia resolves)')}`);
         if (hosted.length)
             console.log(`${muted('Fixtures:')} ${hosted.map((h) => h.name).join(', ')}`);
-        console.log(opts.file ? `${muted('Script:')} ${opts.file}` : `${muted('Expression:')} ${summarizeExpr(expr)}`);
+        console.error(opts.file ? `${muted('Script:')} ${opts.file}` : `${muted('Expression:')} ${summarizeExpr(expr)}`);
         console.log(`\n${result.trim() ? result : muted('(empty result)')}`);
         if (noValue)
             console.log(muted(`\n${EVAL_NO_VALUE_HINT}`));

package/dist/commands/relay.js

@@ -29,7 +29,7 @@ relayCommand
     .option('--name <name>', 'Device name shown in the web CLI (default: this machine\'s hostname)')
     .option('--no-start', 'Pair only; do not start the relay daemon now')
     .option('--no-autostart', 'Skip the OS login service (use when a supervising app owns the daemon)')
-    .option('--force', 'Re-pair even if already paired (revokes the old device first)')
+    .option('--force', 'Re-pair even if already paired (re-registers this machine, rotating its token)')
     .option('--json', 'Machine-readable output')
     .action(async (opts) => {
     const fail = (code, message) => {