gipity 1.0.408 → 1.0.410

package/dist/claude-setup.js

@@ -24,7 +24,7 @@ export function claudeInstallPlan(platformOverride) {
 /** Whether the `claude` binary resolves on PATH. */
 export function isClaudeInstalled(platformOverride) {
     try {
-        execSync(claudeInstallPlan(platformOverride).checkCmd, { stdio: 'ignore' });
+        execSync(claudeInstallPlan(platformOverride).checkCmd, { stdio: 'ignore', windowsHide: true });
         return true;
     }
     catch {
@@ -59,6 +59,7 @@ export function probeClaudeAuthenticated() {
             timeout: 60_000,
             stdio: ['ignore', 'pipe', 'ignore'],
             encoding: 'utf-8',
+            windowsHide: true,
         });
         return typeof out === 'string' && out.trim().length > 0;
     }
@@ -77,7 +78,7 @@ export function ensureClaudeInstalled(opts = {}) {
         return { installed: true, alreadyPresent: true };
     const { installArgv } = claudeInstallPlan();
     try {
-        execSync(installArgv.join(' '), { stdio: opts.quiet ? 'ignore' : 'inherit' });
+        execSync(installArgv.join(' '), { stdio: opts.quiet ? 'ignore' : 'inherit', windowsHide: true });
     }
     catch {
         // Fall through to a definitive PATH re-check rather than trusting the throw.

package/dist/commands/add.js

@@ -5,7 +5,7 @@ import { Command } from 'commander';
 import { post } from '../api.js';
 import { requireConfig } from '../config.js';
 import { sync } from '../sync.js';
-import { success, muted, bold } from '../colors.js';
+import { success, muted, bold, warning } from '../colors.js';
 import { run } from '../helpers/index.js';
 import { createProgressReporter, withSpinner } from '../progress.js';
 const STARTERS = [
@@ -144,7 +144,7 @@ function buildLocalPayload(rootDir) {
     return { name: path.basename(rootDir), files };
 }
 export const addCommand = new Command('add')
-    .description('Add a template (scaffold an app) or a kit (reusable building block) to the project. Pass ./path/to/dir to install a local template directly.')
+    .description('Add a template or kit')
     .argument('[name]', 'Template/kit key, OR a local directory path (./, ~/, or /abs). Omit for help; use --list for just the catalog.')
     .option('--title <title>', 'App title - templates only (defaults to project name)')
     .option('--description <desc>', 'App description for meta tags - templates only')
@@ -225,6 +225,15 @@ export const addCommand = new Command('add')
         for (const n of data.notes)
             console.log(n);
     }
+    // Partial install (server HTTP 207): some files were dropped. Surface them so
+    // the user knows the install is incomplete rather than reading a clean success.
+    if (data.failed?.length) {
+        console.log('');
+        console.warn(warning(`${data.failed.length} file(s) failed to install:`));
+        for (const f of data.failed)
+            console.warn(warning(`  ! ${f.path}: ${f.error}`));
+        console.warn(warning(`Re-run \`gipity add ${data.kit ?? name}${opts.force ? ' --force' : ''}\` to retry the dropped files.`));
+    }
     // After scaffolding an app, point at kits as the next step - they add
     // features (multiplayer, etc.) into the app you just created.
     if (data.kind !== 'kit' && KITS.length > 0) {

package/dist/commands/approval.js

@@ -21,7 +21,7 @@ function keyToIndex(key) {
     return code >= 0 && code < 26 ? code : -1;
 }
 export const approvalCommand = new Command('approval')
-    .description('List, create, answer, or cancel approvals');
+    .description('Manage approvals');
 approvalCommand
     .command('list')
     .description('List pending approvals')

package/dist/commands/bug.js

@@ -0,0 +1,69 @@
+import { Command } from 'commander';
+import { get, post } from '../api.js';
+import { resolveProjectContext } from '../config.js';
+import { bold, muted, success, warning } from '../colors.js';
+import { run } from '../helpers/index.js';
+// Kept in sync with @easyclaw/shared BUG_REPORT_CATEGORIES / _SEVERITIES (the CLI
+// package can't import the server's shared package). The server validates
+// authoritatively; these are for --help and a friendly client-side check.
+const CATEGORIES = ['cli', 'deploy', 'template', 'kit', 'db', 'docs', 'skill', 'service', 'sandbox', 'other'];
+const SEVERITIES = ['S1', 'S2', 'S3', 'S4'];
+const SEVERITY_HINT = 'S1=blocker, S2=major, S3=minor, S4=friction';
+export const bugCommand = new Command('bug')
+    .description('Report Gipity platform bugs / friction in real time')
+    .addHelpText('after', `\nCapture platform friction the moment you hit it — even one you worked around —` +
+    `\nso the team can triage it into a fix.\n` +
+    `\nCategories: ${CATEGORIES.join(', ')}` +
+    `\nSeverity:   ${SEVERITY_HINT}` +
+    `\nNever include PII or user data — describe the platform problem in the abstract.`);
+bugCommand
+    .command('report')
+    .description('File a bug / friction report about the Gipity platform')
+    .requiredOption('--category <cat>', `One of: ${CATEGORIES.join(', ')}`)
+    .requiredOption('--severity <sev>', SEVERITY_HINT)
+    .requiredOption('--summary <text>', 'One line, 7 words max. No PII/user data.')
+    .option('--detail <text>', 'Succinct: what you did, what failed, the workaround. No PII/user data.')
+    .option('--project <guid-or-slug>', 'Attribute to a specific project instead of cwd / Home')
+    .option('--json', 'Output raw JSON')
+    .action((opts) => run('Bug report', async () => {
+    const category = String(opts.category).toLowerCase();
+    const severity = /^[1-4]$/.test(opts.severity) ? `S${opts.severity}` : String(opts.severity).toUpperCase();
+    if (!CATEGORIES.includes(category))
+        throw new Error(`--category must be one of: ${CATEGORIES.join(', ')}`);
+    if (!SEVERITIES.includes(severity))
+        throw new Error(`--severity must be one of: ${SEVERITY_HINT}`);
+    if (String(opts.summary).trim().split(/\s+/).filter(Boolean).length > 7) {
+        throw new Error('--summary must be 7 words or fewer');
+    }
+    const { config } = await resolveProjectContext({ projectOverride: opts.project });
+    const res = await post(`/api/${config.projectGuid}/services/bug-report/submit`, { category, severity, summary: opts.summary, detail: opts.detail });
+    if (opts.json) {
+        console.log(JSON.stringify(res.data));
+        return;
+    }
+    console.log(success(`✓ Bug report filed (${res.data.report_guid}) — queued for triage.`));
+}));
+bugCommand
+    .command('list')
+    .description('List the bug / friction reports you have filed')
+    .option('--project <guid-or-slug>', 'Resolve auth against a specific project instead of cwd / Home')
+    .option('--json', 'Output raw JSON')
+    .action((opts) => run('Bug report', async () => {
+    const { config } = await resolveProjectContext({ projectOverride: opts.project });
+    const res = await get(`/api/${config.projectGuid}/services/bug-report/list`);
+    if (opts.json) {
+        console.log(JSON.stringify(res.data));
+        return;
+    }
+    const rows = res.data;
+    if (!rows.length) {
+        console.log(warning('No bug reports filed yet.'));
+        return;
+    }
+    console.log(bold(`${rows.length} report${rows.length === 1 ? '' : 's'}`));
+    for (const r of rows) {
+        console.log(`  ${r.severity}  ${muted(r.category.padEnd(8))} ${r.summary}  ${muted(`[${r.status}]`)}`);
+        console.log(muted(`      ${r.report_guid}  ${r.created_at}`));
+    }
+}));
+//# sourceMappingURL=bug.js.map

package/dist/commands/credits.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
-import { spawn } from 'node:child_process';
-import { get } from '../api.js';
-import { brand, muted } from '../colors.js';
+import { spawnCommand } from '../platform.js';
+import { get, post, ApiError } from '../api.js';
+import { brand, dim, bold, muted, success } from '../colors.js';
 import { run, printList } from '../helpers/index.js';
 const PRICING_URL = 'https://prompt.gipity.ai/pricing';
 function openInBrowser(url) {
@@ -12,7 +12,7 @@ function openInBrowser(url) {
         process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]] :
             ['xdg-open', [url]];
     try {
-        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        const child = spawnCommand(cmd, args, { stdio: 'ignore', detached: true });
         // A missing/non-executable launcher (ENOENT, or EACCES on WSL/minimal Linux
         // where xdg-open isn't runnable) is reported ASYNCHRONOUSLY via an 'error'
         // event - not a throw - so the try/catch alone can't stop it. With no
@@ -25,18 +25,92 @@ function openInBrowser(url) {
         // Synchronous spawn failure - caller prints the URL.
     }
 }
+// ---- Plan limits formatting (folded in from the old `plan` command) ----
+// Every key the plan definition enforces is rendered, so `credits` /
+// `credits list` are a full-transparency view of what your plan actually caps.
+const LIMIT_LABELS = {
+    maxProjects: 'Projects',
+    maxDatabases: 'Databases',
+    storageQuotaBytes: 'Storage',
+    maxWorkflows: 'Workflows',
+    minCronIntervalHours: 'Cron frequency',
+    maxConcurrentChats: 'Concurrent chats',
+    deployRatePerMinute: 'Deploys/min',
+    testFileConcurrency: 'Parallel tests',
+};
+// Nested serviceLimits (media generation entitlements). Convention:
+// -1 = unlimited, 0 = Pro-only (blocked on free), N = N free uses/month.
+const SERVICE_LABELS = {
+    video: 'Video generation',
+    music: 'Music generation',
+    image: 'Image generation',
+    audio: 'Speech & sound FX',
+};
+function formatLimit(key, value) {
+    if (typeof value !== 'number')
+        return String(value);
+    if (key === 'storageQuotaBytes') {
+        const gb = value / (1024 ** 3);
+        return `${gb.toFixed(gb >= 1 ? 1 : 2)} GB`;
+    }
+    if (key === 'minCronIntervalHours') {
+        return value === 0 ? 'no minimum' : `${value}h minimum`;
+    }
+    return value.toLocaleString();
+}
+function formatServiceLimit(value) {
+    if (value === -1)
+        return 'unlimited';
+    if (value === 0)
+        return 'Pro only';
+    if (typeof value === 'number')
+        return `${value.toLocaleString()}/mo free`;
+    return String(value);
+}
+function renderLimits(limits, indent = '') {
+    for (const key of Object.keys(LIMIT_LABELS)) {
+        const value = limits[key];
+        if (value !== undefined) {
+            console.log(`${indent}${LIMIT_LABELS[key].padEnd(18)} ${formatLimit(key, value)}`);
+        }
+    }
+    const services = limits.serviceLimits;
+    if (services && typeof services === 'object') {
+        console.log(`${indent}Media generation`);
+        for (const key of Object.keys(SERVICE_LABELS)) {
+            const value = services[key];
+            if (value !== undefined) {
+                console.log(`${indent}  ${SERVICE_LABELS[key].padEnd(16)} ${formatServiceLimit(value)}`);
+            }
+        }
+    }
+}
+// `credits` is the single account/billing hub: tier, live balance, the full set
+// of plan limits, and an upgrade nudge. `plan` aliases to it (so old muscle
+// memory resolves to one implementation); compare plans with `plan list`.
 export const creditsCommand = new Command('credits')
-    .description('View credits')
+    .alias('plan')
+    .description('Show your plan, credit balance, and limits')
     .option('--json', 'Output as JSON')
     .action((opts) => run('Credits', async () => {
+    // Version retention rides alongside the Storage limit; a failure fetching it
+    // must not sink the whole view, so degrade to null and omit the line.
+    const fetchRetention = () => get('/users/me/retention').then(r => r.data).catch(() => null);
     if (opts.json) {
-        const res = await get('/credits/balance');
-        console.log(JSON.stringify(res.data));
+        const [balRes, limitsRes, subRes, retention] = await Promise.all([
+            get('/credits/balance'),
+            get('/users/me/limits'),
+            get('/credits/subscription'),
+            fetchRetention(),
+        ]);
+        console.log(JSON.stringify({ subscription: subRes.data, balance: balRes.data, limits: limitsRes.data, retention }));
         return;
     }
-    const [balRes, subRes] = await Promise.all([
+    const [balRes, subRes, limitsRes, retention] = await Promise.all([
         get('/credits/balance'),
         get('/credits/subscription'),
+        get('/users/me/limits'),
+        fetchRetention(),
     ]);
     const sub = subRes.data;
     const tierLabel = sub.tier === 'pro' ? 'Gipity Pro' : 'Free';
@@ -45,17 +119,170 @@ export const creditsCommand = new Command('credits')
     if (balRes.data.balances.length > 0) {
         for (const b of balRes.data.balances) {
             const exp = new Date(b.expiresAt).toLocaleDateString();
-            console.log(`${b.source}: ${b.creditsRemaining.toLocaleString()}  ${muted(`expires ${exp}`)}`);
+            console.log(`  ${b.source}: ${b.creditsRemaining.toLocaleString()}  ${muted(`expires ${exp}`)}`);
         }
     }
+    console.log('\nLimits:');
+    renderLimits(limitsRes.data.limits, '  ');
+    if (retention) {
+        console.log(`  ${'Version retention'.padEnd(18)} ${retention.days} days / ${retention.count} copies`);
+    }
+    console.log('');
+    if (sub.tier !== 'pro') {
+        console.log(dim('Upgrade to Gipity Pro for higher limits and 20,000 credits/mo — run `gipity credits buy`.'));
+    }
+    else {
+        console.log(dim('Need more credits? Run `gipity credits list` to see credit packs, then `gipity credits buy <pack>`.'));
+    }
 }));
+// `credits list` compares every plan (with full limits) and the available
+// credit packs — the "what can I upgrade to" view.
 creditsCommand
-    .command('buy')
-    .description('Open the credits purchase page in your browser')
-    .action(() => run('Buy credits', async () => {
-    console.log(`Opening ${brand(PRICING_URL)} in your browser...`);
-    openInBrowser(PRICING_URL);
-    console.log(muted("If your browser didn't open automatically, copy the URL above."));
+    .command('list')
+    .description('Compare all plans and credit packs')
+    .option('--json', 'Output as JSON')
+    // optsWithGlobals(): the parent `credits` command also declares --json, which
+    // commander binds to the parent - read merged opts so --json is seen here.
+    .action((_opts, cmd) => run('Plans', async () => {
+    const opts = cmd.optsWithGlobals();
+    const [plansRes, productsRes, subRes] = await Promise.all([
+        get('/plans'),
+        get('/credits/products'),
+        get('/credits/subscription'),
+    ]);
+    if (opts.json) {
+        console.log(JSON.stringify({ currentTier: subRes.data.tier, plans: plansRes.data, products: productsRes.data }));
+        return;
+    }
+    const currentTier = subRes.data.tier;
+    const plans = plansRes.data;
+    if (plans.length === 0) {
+        console.log('No active plans.');
+        return;
+    }
+    console.log(bold('Plans'));
+    for (const plan of plans) {
+        const marker = plan.tier === currentTier ? brand('* ') : '  ';
+        const price = plan.monthlyPriceUsd > 0 ? ` - $${plan.monthlyPriceUsd}/mo` : ' - Free';
+        const credits = plan.monthlyCredits > 0
+            ? ` - ${plan.monthlyCredits.toLocaleString()} credits/mo (${plan.creditExpiryDays}-day expiry)`
+            : '';
+        console.log(`${marker}${plan.displayName} (${plan.tier})${price}${credits}`);
+        renderLimits(plan.limits, '      ');
+        console.log('');
+    }
+    const packs = productsRes.data.filter(p => p.type === 'one_time');
+    if (packs.length > 0) {
+        console.log(bold('Credit packs') + muted('  (require an active Pro subscription)'));
+        for (const pack of packs) {
+            const lock = pack.available ? '' : muted('  [Pro only]');
+            console.log(`  ${pack.name} - $${pack.amountUsd} - ${pack.credits.toLocaleString()} credits${lock}`);
+        }
+        console.log('');
+    }
+    console.log(dim('* = your current plan.  Upgrade or top up with `gipity credits buy [pro|<pack-credits>]`.'));
+}));
+// `credits buy` is the ONE purchase command. It resolves the target to a
+// Stripe price and prints a checkout link (agent-friendly: the link is always
+// printed so it can be relayed to the user; --open also launches a browser).
+creditsCommand
+    .command('buy [target]')
+    .alias('upgrade')
+    .description('Upgrade your plan or buy a credit pack (target: a tier like "pro", or a pack credit amount)')
+    .option('--open', 'Open the checkout page in your browser')
+    .option('--json', 'Output the checkout URL as JSON')
+    // optsWithGlobals(): the parent `credits` command also declares --json, which
+    // commander binds to the parent - read merged opts so --json/--open are seen here.
+    .action((target, _opts, cmd) => run('Buy', async () => {
+    const opts = cmd.optsWithGlobals();
+    const [productsRes, subRes] = await Promise.all([
+        get('/credits/products'),
+        get('/credits/subscription'),
+    ]);
+    const products = productsRes.data;
+    const currentTier = subRes.data.tier;
+    // Resolve the target product. With no arg, default to the first available
+    // paid subscription (the upgrade path). With an arg, match a plan/pack by
+    // name or credit amount, mirroring the cloud agent's product keys.
+    // Non-happy exits must stay parseable under --json (agents rely on it), so
+    // emit a JSON { error } instead of prose when the flag is set.
+    const bail = (message, humanLines) => {
+        if (opts.json)
+            console.log(JSON.stringify({ error: message }));
+        else
+            for (const line of humanLines)
+                console.log(line);
+    };
+    let product;
+    if (!target) {
+        product = products.find(p => p.type === 'subscription' && p.available);
+        if (!product) {
+            bail(currentTier === 'pro'
+                ? "You're already on Gipity Pro. To top up credits, run `gipity credits list` and buy a pack, e.g. `gipity credits buy 20000`."
+                : 'No upgrade plan is available right now.', [
+                currentTier === 'pro'
+                    ? `You're already on ${brand('Gipity Pro')}. To top up credits, run \`gipity credits list\` and buy a pack, e.g. \`gipity credits buy 20000\`.`
+                    : 'No upgrade plan is available right now.',
+                dim(`Browse everything at ${PRICING_URL}`),
+            ]);
+            return;
+        }
+    }
+    else {
+        const key = target.toLowerCase();
+        product = products.find(p => p.type === 'subscription' && p.name.toLowerCase() === key)
+            // pack keyed by credit amount, e.g. "20000" - MUST be a pack, not a
+            // subscription (Pro's monthly_credits can equal a pack's credit count).
+            ?? products.find(p => p.type === 'one_time' && String(p.credits) === key)
+            // accept "pro" against the single paid plan when only one exists
+            ?? (key === 'pro' ? products.find(p => p.type === 'subscription') : undefined);
+        if (!product) {
+            bail(`Unknown option "${target}". Run \`gipity credits list\` to see plans and packs.`, [`Unknown option "${target}". Run \`gipity credits list\` to see plans and packs.`]);
+            return;
+        }
+        if (!product.available) {
+            bail(product.type === 'subscription'
+                ? `You're already on ${product.name}.`
+                : 'Credit packs require an active Pro subscription. Run `gipity credits buy pro` first.', [product.type === 'subscription'
+                    ? `You're already on ${brand(product.name)}.`
+                    : 'Credit packs require an active Pro subscription. Run `gipity credits buy pro` first.']);
+            return;
+        }
+    }
+    try {
+        const res = await post('/credits/purchase', { priceId: product.priceId });
+        const url = res.data.checkoutUrl;
+        if (opts.json) {
+            console.log(JSON.stringify({ product: product.name, amountUsd: product.amountUsd, checkoutUrl: url }));
+            return;
+        }
+        const verb = product.type === 'subscription' ? 'Upgrading to' : 'Buying';
+        const per = product.type === 'subscription' ? '/mo' : '';
+        console.log(`${verb} ${brand(product.name)} ${muted(`($${product.amountUsd}${per}, ${product.credits.toLocaleString()} credits)`)}`);
+        console.log('');
+        console.log(`  ${bold('Checkout:')} ${success(url)}`);
+        console.log('');
+        console.log(dim('Open the link to complete your purchase — 2 minutes, cancel anytime. Your plan unlocks the moment payment clears.'));
+        if (opts.open)
+            openInBrowser(url);
+    }
+    catch (err) {
+        // Payments not configured / Stripe hiccup: fall back to the pricing page
+        // so the user is never dead-ended.
+        if (err instanceof ApiError) {
+            if (opts.json) {
+                console.log(JSON.stringify({ error: err.message, checkoutUrl: null, fallbackUrl: PRICING_URL }));
+            }
+            else {
+                console.log(muted(`Couldn't create a direct checkout link (${err.message}).`));
+                console.log(`Complete your purchase at ${brand(PRICING_URL)}`);
+            }
+            if (opts.open)
+                openInBrowser(PRICING_URL);
+            return;
+        }
+        throw err;
+    }
 }));
 creditsCommand
     .command('usage')

package/dist/commands/email.js

@@ -7,7 +7,8 @@ function collect(value, prev) {
     return [...prev, value];
 }
 export const emailCommand = new Command('email')
-    .description('Send email from the Gipity platform (gipity@gipity.ai). Omit --to to self-send.')
+    .description('Send email')
+    .addHelpText('after', '\nSends from gipity@gipity.ai. Omit --to to self-send.')
     .requiredOption('--subject <subject>', 'Email subject')
     .requiredOption('--body <body>', 'Email body (plain text)')
     .option('--to <email>', 'Recipient (repeatable; omit for self-send)', collect, [])

package/dist/commands/gmail.js

@@ -3,7 +3,8 @@ import { get, post } from '../api.js';
 import { run, printList, printResult } from '../helpers/index.js';
 import { muted } from '../colors.js';
 export const gmailCommand = new Command('gmail')
-    .description('Send, reply, search, or read via your Gmail (user channel - separate from `gipity email`)');
+    .description('Use your Gmail')
+    .addHelpText('after', '\nSend, reply, search, or read via your own Gmail (separate from `gipity email`).');
 gmailCommand
     .command('search <query...>')
     .description('Search your Gmail (standard Gmail search syntax)')

package/dist/commands/init.js

@@ -22,7 +22,8 @@ function resolveTools(forFlag) {
     return SUPPORTED_TOOLS.filter(t => requested.includes(t.key) || (!t.optIn && requested.includes('all')));
 }
 export const initCommand = new Command('init')
-    .description('Link this directory to a Gipity project (writes primer files so your AI coding tool understands Gipity)')
+    .description('Link this directory to a project')
+    .addHelpText('after', '\nWrites CLAUDE.md/AGENTS.md primer files so your AI coding tool understands Gipity.')
     .argument('[name]', 'Project name/slug (defaults to current directory name)')
     .option('--agent <guid>', 'Agent GUID to use')
     .option('--for <tools>', `Which AI tool primer files to write (comma-separated). Default: all except aider (opt-in - it also writes .aider.conf.yml). Choices: ${TOOL_KEYS.join(', ')}, all`)

package/dist/commands/job.js

@@ -4,7 +4,8 @@ import { requireConfig } from '../config.js';
 import { error as clrError, bold, muted, success, warning as warn } from '../colors.js';
 import { run, printList } from '../helpers/index.js';
 export const jobCommand = new Command('job')
-    .description('Long-running jobs - CPU sandbox or GPU via Modal (gpu-small=L4, gpu-medium=A10G, gpu-large=A100, gpu-huge=H100). Declared in gipity.yaml jobs: phase; submit + poll via subcommands below.');
+    .description('Run long jobs (CPU/GPU)')
+    .addHelpText('after', '\nCPU sandbox or GPU (gpu-small=L4, gpu-medium=A10G, gpu-large=A100, gpu-huge=H100). Declared in the gipity.yaml jobs: phase; submit and poll via the subcommands below.');
 jobCommand
     .command('list')
     .description('List jobs')
@@ -192,7 +193,7 @@ jobCommand
     .action(async (name, opts) => {
     const { existsSync, statSync } = await import('node:fs');
     const { resolve, join } = await import('node:path');
-    const { spawn, spawnSync } = await import('node:child_process');
+    const { spawnCommand, spawnSyncCommand } = await import('../platform.js');
     const jobDir = resolve(process.cwd(), 'jobs', name);
     if (!existsSync(jobDir) || !statSync(jobDir).isDirectory()) {
         console.error(clrError(`jobs/${name}/ not found in current directory`));
@@ -212,7 +213,7 @@ jobCommand
         process.exit(1);
     }
     // Confirm docker is reachable before bothering to build args.
-    const probe = spawnSync('docker', ['info'], { stdio: 'ignore' });
+    const probe = spawnSyncCommand('docker', ['info'], { stdio: 'ignore' });
     if (probe.status !== 0) {
         console.error(clrError('docker daemon not reachable. Start Docker Desktop / dockerd and retry.'));
         process.exit(1);
@@ -239,7 +240,7 @@ jobCommand
         shellCmd = `echo '[run-local] running ${handlerCmd} (${picked.runtime})' >&2 && exec ${handlerCmd}`;
     }
     const runArgs = ['run', ...sharedArgs, '--entrypoint', 'sh', opts.image, '-c', shellCmd];
-    const child = spawn('docker', runArgs, { stdio: 'inherit' });
+    const child = spawnCommand('docker', runArgs, { stdio: 'inherit' });
     // A missing `docker` binary is reported asynchronously via 'error' (not a
     // throw), so a try/catch can't stop it - without this handler Node crashes
     // with a raw stack trace instead of a clear message.

package/dist/commands/login.js

@@ -34,6 +34,7 @@ export const loginCommand = new Command('login')
             process.exit(1);
         }
         await publicPost('/auth/login', { email });
+        console.log('');
         console.log('Check your email for a 6-digit code.');
         code = await prompt('Code: ');
         await verify(email, code);

package/dist/commands/notify.js

@@ -4,7 +4,8 @@ import { resolveProjectContext } from '../config.js';
 import { bold, muted, success, warning } from '../colors.js';
 import { run } from '../helpers/index.js';
 export const notifyCommand = new Command('notify')
-    .description('Gipity Notify (web push): send a test notification or inspect subscriptions');
+    .description('Web push notifications')
+    .addHelpText('after', '\nGipity Notify: send a test notification or inspect subscriptions.');
 notifyCommand
     .command('test')
     .description('Send a test push notification to yourself, a user, or everyone')

package/dist/commands/page.js

@@ -10,7 +10,7 @@ import { pageFetchCommand } from './page-fetch.js';
 // top-level surface lean and makes the siblings discoverable via `page --help`.
 // `inspect` is the rendered DOM (browser); `fetch` is the raw asset (plain HTTP).
 export const pageCommand = new Command('page')
-    .description('Inspect, evaluate, screenshot, multi-client test, and verify raw files of web pages (page inspect | eval | screenshot | test | fetch)')
+    .description('Inspect web pages')
     .addCommand(pageInspectCommand)
     .addCommand(pageEvalCommand)
     .addCommand(pageScreenshotCommand)

package/dist/commands/payments.js

@@ -19,7 +19,8 @@ function renderStatus(status) {
     }
 }
 export const paymentsCommand = new Command('payments')
-    .description('Connect Stripe so your app can charge its users (one-time + subscriptions)');
+    .description('Charge your users via Stripe')
+    .addHelpText('after', '\nAccept one-time purchases and subscriptions. Set up with `gipity payments connect`.');
 paymentsCommand
     .command('connect')
     .description('Start (or resume) Stripe onboarding for this app — prints a link to finish in your browser')

package/dist/commands/plan.js

@@ -31,7 +31,7 @@ function renderLimits(limits, indent = '') {
     }
 }
 export const planCommand = new Command('plan')
-    .description('Show your current subscription plan and limits')
+    .description('Show your plan')
     .option('--json', 'Output as JSON')
     .action((opts) => run('Plan', async () => {
     const [limitsRes, plansRes] = await Promise.all([

package/dist/commands/push.js

@@ -11,9 +11,13 @@ export const pushCommand = new Command('push')
     try {
         const fullPath = resolve(file);
         if (opts.background) {
-            // Fork to background - import child_process dynamically
-            const { fork } = await import('child_process');
-            const child = fork(process.argv[1], ['push', fullPath, '--quiet'], {
+            // Detach a background `gipity push` and exit immediately. Goes through
+            // spawnCommand (Node binary running our own entry script - no IPC
+            // channel is needed, so spawn beats fork), which defaults
+            // `windowsHide: true` so the detached child never flashes a console
+            // window on Windows.
+            const { spawnCommand } = await import('../platform.js');
+            const child = spawnCommand(process.execPath, [process.argv[1], 'push', fullPath, '--quiet'], {
                 detached: true,
                 stdio: 'ignore',
             });

package/dist/commands/relay.js

@@ -14,7 +14,7 @@ import { bold, brand, dim, success, error as clrError, muted, } from '../colors.
 import * as state from '../relay/state.js';
 import * as daemon from '../relay/daemon.js';
 import { UnsupportedPlatformError } from '../relay/installers.js';
-import { pairDevice, startDaemon, installAutostart } from '../relay/setup.js';
+import { pairDevice, startDaemon, installAutostart, removeAutostart } from '../relay/setup.js';
 import { registerInstallCommands } from './relay-install.js';
 export const relayCommand = new Command('relay')
     .description('Pair with the web CLI');
@@ -269,8 +269,32 @@ relayCommand
         console.error(muted('Local token cleared anyway. Visit the web CLI to confirm the server-side revoke.'));
     }
     state.clearDevice();
+    // Remove the OS autostart unit too. Otherwise the login service relaunches
+    // `relay run`, which - finding no device but a valid login - silently
+    // re-registers a NEW device, undoing this revoke (on macOS the old
+    // KeepAlive=true even relaunched on the clean exit). Best-effort: an
+    // unsupported OS or a missing unit is fine.
+    let autostartRemoved = false;
+    try {
+        autostartRemoved = removeAutostart().ok;
+    }
+    catch { /* unsupported platform / no unit - ignore */ }
+    // Stop the currently-running daemon now rather than waiting for it to
+    // notice via a 401 on its next poll (~up to a hold cycle).
+    const pidPath = state.getDaemonPidPath();
+    if (existsSync(pidPath)) {
+        const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+        if (pid && !isNaN(pid)) {
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch { /* already gone */ }
+        }
+    }
     console.log(success('Device revoked + local state cleared.'));
-    console.log(muted('Any running background service will notice and exit within ~30s.'));
+    console.log(muted(autostartRemoved
+        ? 'Auto-start removed and the background service was signalled to stop.'
+        : 'The background service was signalled to stop.'));
 });
 // ─── gipity relay log ──────────────────────────────────────────────────
 relayCommand