@prave/cli 1.4.6 → 1.4.8

package/dist/commands/import.js

@@ -123,17 +123,17 @@ export async function importCommand(opts) {
     const me = await fetchMyPlan();
     if (!me.limits.can_authoring_public && !me.limits.can_authoring_private) {
         log.warn('Uploading Skills requires the Pro plan or higher.');
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         return;
     }
     if (visibility === 'private' && !me.limits.can_authoring_private) {
         log.warn('Private uploads require the Pro plan.');
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         return;
     }
     if (visibility === 'public' && !me.limits.can_authoring_public) {
         log.warn('Public uploads require the Pro plan.');
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         return;
     }
     // Clamp the queue to the caller's authoring ceiling. `null` = unlimited
@@ -142,7 +142,7 @@ export async function importCommand(opts) {
     if (me.limits.authoring_max_skills !== null &&
         queue.length > me.limits.authoring_max_skills) {
         log.warn(`Your ${me.limits.label} plan caps authored Skills at ${me.limits.authoring_max_skills}. Trimming queue from ${queue.length} → ${me.limits.authoring_max_skills}.`);
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         queue = queue.slice(0, me.limits.authoring_max_skills);
     }
     const uploadSpinner = ora(`Uploading ${queue.length} skills as ${visibility}…`).start();
@@ -191,7 +191,7 @@ export async function importCommand(opts) {
         .join(' · ');
     uploadSpinner.succeed(tail);
     if (gated > 0)
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
     // Always analyze after upload — best effort, never blocks the user.
     const analyzeSpinner = ora(`Analyzing ${queue.length} skills…`).start();
     for (const s of queue) {

package/dist/commands/install.js

@@ -1,12 +1,12 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { createInterface } from 'node:readline/promises';
 import chalk from 'chalk';
 import ora from 'ora';
 import { track } from '../lib/analytics.js';
 import { api, ApiError } from '../lib/api.js';
 import { CONFIG } from '../lib/config.js';
 import { loadCredentials, requireAuth } from '../lib/credentials.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { fetchMyPlan, formatUpgradeHint } from '../lib/plan.js';
 import { assertSlug, InvalidSlugError } from '../lib/slug.js';
 import { log } from '../utils/logger.js';
@@ -51,7 +51,7 @@ export async function installCommand(slug, opts = {}) {
             const remaining = data.installs.remaining;
             if (remaining !== null && remaining <= 0) {
                 log.warn(`Your ${me.limits.label} plan caps installs at ${me.limits.install_monthly_limit}/month. You've used all of them.`);
-                log.dim(formatUpgradeHint('explorer'));
+                log.dim(formatUpgradeHint('pro'));
                 process.exitCode = 1;
                 return;
             }
@@ -102,22 +102,13 @@ export async function installCommand(slug, opts = {}) {
             /* file unreadable — skip */
         }
     }
-    // Offer to deploy to all configured agents — unless the caller already
-    // answered the question (e.g. `prave sync` collects the answer once for
-    // the whole batch and threads it through `skipDeployPrompt`).
-    if (opts.skipDeployPrompt)
-        return;
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const ans = (await rl.question('\nDeploy to all configured agents? [y/N] ')).trim().toLowerCase();
-        if (ans === 'y' || ans === 'yes') {
-            const { deployCommand } = await import('./deploy.js');
-            await deployCommand(slug, {});
-        }
-    }
-    finally {
-        rl.close();
-    }
+    // `prave deploy` was retired — install fans out to the user's
+    // configured agent targets directly (see multi_agent_targets in
+    // PLAN_LIMITS), so no follow-up prompt is needed.
+    // Defensive: requireAuth above already blocks unauth callers, so this
+    // is a no-op today. Keeps the nudge consistent if install ever opens
+    // to anonymous use (it's safe — `nudgeAfter` self-gates on auth).
+    await nudgeAfter('install');
 }
 async function pullOne(slug, ctx) {
     const { data: skill } = await api.get(`/api/v1/skills/${encodeURIComponent(slug)}`, ctx.hasSession);

package/dist/commands/list.js

@@ -5,7 +5,7 @@ import { tokenTier } from '@prave/shared';
 import { track } from '../lib/analytics.js';
 import { api } from '../lib/api.js';
 import { CONFIG } from '../lib/config.js';
-import { nudgeIfAnonymous } from '../lib/nudge.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { log } from '../utils/logger.js';
 const TIER_EMOJI = {
     lean: '🟢',
@@ -69,7 +69,7 @@ export async function listCommand(opts = {}) {
             console.log(`  ${chalk.cyan('•')} ${name}`);
         }
         log.dim(`\n${localSlugs.length} local skill${localSlugs.length === 1 ? '' : 's'} in ${CONFIG.skillsDir}`);
-        await nudgeIfAnonymous('list');
+        await nudgeAfter('list');
         return;
     }
     // Enriched path — pull intelligence and merge by slug (best-effort).

package/dist/commands/login.js

@@ -39,6 +39,7 @@ export async function loginCommand() {
                 expires_at: data.expires_at ?? undefined,
             });
             spinner.succeed('Logged in.');
+            log.dim("Nudges disabled — you're all set.");
             // Replay any Skill-invocation events the hook buffered while the
             // user was offline / signed out. Silent when nothing's queued;
             // prints "Syncing N events…" + a confirmation when the file has

package/dist/commands/overview.js

@@ -3,6 +3,7 @@ import ora from 'ora';
 import { track } from '../lib/analytics.js';
 import { api, ApiError } from '../lib/api.js';
 import { requireAuth } from '../lib/credentials.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { log } from '../utils/logger.js';
 function formatThousands(n) {
     if (n < 1000)
@@ -71,5 +72,9 @@ export async function overviewCommand(opts = {}) {
         spinner.stop();
         log.error(err instanceof ApiError ? err.message : err.message);
         process.exitCode = 1;
+        return;
     }
+    // No-op for signed-in users (overview requires auth), but harmless and
+    // future-proof if we ever expose a public overview-equivalent.
+    await nudgeAfter('overview');
 }

package/dist/commands/search.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { track } from '../lib/analytics.js';
 import { api } from '../lib/api.js';
-import { nudgeIfAnonymous } from '../lib/nudge.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { log } from '../utils/logger.js';
 const SLUG_COL = 32;
 function formatInstalls(n) {
@@ -42,5 +42,5 @@ export async function searchCommand(query) {
     if (skills.length > 0) {
         console.log(chalk.dim('  → prave install <slug>'));
     }
-    await nudgeIfAnonymous('search');
+    await nudgeAfter('search');
 }

package/dist/commands/sync.js

@@ -72,11 +72,11 @@ export async function syncCommand() {
     const session = await requireAuth('prave sync');
     if (!session)
         return;
-    // Plan gate: sync requires Explorer or higher.
+    // Plan gate: sync requires Pro or higher.
     const me = await fetchMyPlan();
     if (!me.limits.can_cli_sync) {
-        log.warn('Sync requires the Explorer plan or higher.');
-        log.dim(formatUpgradeHint('explorer'));
+        log.warn('Sync requires the Pro plan or higher.');
+        log.dim(formatUpgradeHint('pro'));
         return;
     }
     // Last-sync nudge. We read state up-front because if the user bails on
@@ -134,19 +134,10 @@ export async function syncCommand() {
     // Pre-flight time estimate — sets expectations before the user hits Y.
     const estSeconds = estimateSeconds(slugs.length);
     console.log(chalk.dim(`Syncing ${slugs.length} Skill${slugs.length === 1 ? '' : 's'} — this takes about ${estSeconds} seconds.`));
-    // Ask the deploy question ONCE for the whole batch.
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    let deployAfter = false;
-    try {
-        const ans = (await rl.question(`\nAfter syncing, deploy all ${slugs.length} Skills to your configured agents? [y/N] `))
-            .trim()
-            .toLowerCase();
-        deployAfter = ans === 'y' || ans === 'yes';
-    }
-    finally {
-        rl.close();
-    }
-    // Parallel install with live progress counter.
+    // Parallel install with live progress counter. The legacy post-sync
+    // "deploy to all agents?" prompt is gone — `prave deploy` has been
+    // retired and `installCommand` already fans out to the user's
+    // configured agent targets directly.
     const progress = ora(`Installed 0 / ${slugs.length}`).start();
     let done = 0;
     let updated = 0;
@@ -174,18 +165,6 @@ export async function syncCommand() {
     // *did* attempt a sync, and we want the cooldown to apply to retries
     // just as much as to the happy path.
     await writeState({ last_sync_at: new Date().toISOString() }).catch(() => { });
-    if (deployAfter && updated > 0) {
-        const { deployCommand } = await import('./deploy.js');
-        log.info(`\nDeploying ${updated} Skills to configured agents…`);
-        for (const slug of slugs) {
-            try {
-                await deployCommand(slug, {});
-            }
-            catch (err) {
-                log.warn(`  ✗ deploy ${slug} — ${err.message}`);
-            }
-        }
-    }
     // Tail end of sync: fire a quiet usage scan so the optimiser stays warm
     // without the user having to remember an extra command. Quiet mode means
     // we only log a one-liner ("Usage: 12 new, 88 known.") instead of taking

package/dist/commands/update.js

@@ -30,7 +30,7 @@ export async function updateCommand(slug, opts = {}) {
     const me = await fetchMyPlan();
     if (!me.limits.can_cli_update) {
         log.warn(`\`prave update\` requires the Pro plan or higher.`);
-        log.dim(formatUpgradeHint('explorer'));
+        log.dim(formatUpgradeHint('pro'));
         process.exitCode = 1;
         return;
     }

package/dist/commands/whatdoes.js

@@ -3,7 +3,7 @@ import ora from 'ora';
 import { tokenTier } from '@prave/shared';
 import { track } from '../lib/analytics.js';
 import { api, ApiError } from '../lib/api.js';
-import { nudgeIfAnonymous } from '../lib/nudge.js';
+import { nudgeAfter } from '../lib/nudge.js';
 import { log } from '../utils/logger.js';
 const TIER_BADGE = {
     lean: chalk.green('🟢 Lean'),
@@ -72,7 +72,7 @@ export async function whatdoesCommand(skillName) {
         console.log(`🔗 Requires:      ${requires}`);
         console.log(`${data.conflicts.length > 0 ? chalk.yellow('⚠️ ') : '⚠️ '}Conflicts:     ${conflicts}`);
         console.log(chalk.dim(RULE));
-        await nudgeIfAnonymous('whatdoes');
+        await nudgeAfter('whatdoes');
     }
     catch (err) {
         spinner.stop();

package/dist/commands/whoami.js

@@ -11,7 +11,7 @@ import { log } from '../utils/logger.js';
  * is the only thing that ever surfaces in UI / CLI copy.
  */
 function planDisplay(plan) {
-    if (plan === 'free' || plan === 'explorer' || plan === 'creator') {
+    if (plan === 'free' || plan === 'pro' || plan === 'max') {
         return planLabel(plan);
     }
     return plan;

package/dist/index.js

@@ -15,7 +15,6 @@ import { mcpInstallCommand } from './commands/mcp-install.js';
 import { mcpServerCommand } from './commands/mcp-server.js';
 import { optimizeCommand } from './commands/optimize.js';
 import { overviewCommand } from './commands/overview.js';
-import { runDeployCommand, runListCommand, runLogsCommand, runTriggerCommand, } from './commands/run.js';
 import { searchCommand } from './commands/search.js';
 import { settingsCommand } from './commands/settings.js';
 import { syncCommand } from './commands/sync.js';
@@ -25,6 +24,7 @@ import { usageHookInstallCommand, usageHookUninstallCommand, usageReportCommand,
 import { whatdoesCommand } from './commands/whatdoes.js';
 import { whoamiCommand } from './commands/whoami.js';
 import { initAnalytics } from './lib/analytics.js';
+import { nudgeFirstRun } from './lib/nudge.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf8'));
 initAnalytics(pkg.version);
@@ -40,7 +40,6 @@ const program = new Command()
     '    prave login          # device-code auth in your browser',
     '    prave search <q>     # discover community skills',
     '    prave install <slug> # pull into ~/.claude/skills/ (multi-agent prompt included)',
-    '    prave run deploy     # bundle cwd, schedule on Prave\'s sandbox',
     '    prave usage hook install   # real-time invocation tracking',
     '',
     '  Docs:    https://prave.app/docs',
@@ -151,30 +150,6 @@ program
     .command('docs [slug]')
     .description('Open the docs in your browser. Bare `prave docs` lands on the home page; `prave docs cli/run` or `prave docs web/runs` jumps straight to a section.')
     .action((slug) => docsCommand(slug));
-// ─── prave run — scheduled server-side executions (Runs) ──────────
-const run = program
-    .command('run')
-    .description('Schedule a skill to fire on a cron, executed by your chosen AI agent on Prave\'s sandbox. Bring the whole project — SKILL.md, scripts, .env.');
-run
-    .command('deploy [path]')
-    .description('Bundle the current directory (or `path`), upload it to Prave, and open the browser wizard to pick the schedule + agent.')
-    .action((path) => runDeployCommand(path));
-run
-    .command('update <slug> [path]')
-    .description("Re-upload the bundle for an existing run. Same flow as `deploy`, but the run's schedule, agent and env vars stay intact — only the project files swap.")
-    .action((slug, path) => runDeployCommand(path, { updateRunSlug: slug }));
-run
-    .command('list')
-    .description('List your scheduled runs with next-fire time + last status.')
-    .action(runListCommand);
-run
-    .command('logs <slug>')
-    .description('Print the latest execution log for a scheduled run.')
-    .action(runLogsCommand);
-run
-    .command('trigger <slug>')
-    .description('Fire a one-shot execution outside the cron schedule. Refused with 409 if another execution is already in flight. Tail with `prave run logs <slug>` afterwards.')
-    .action(runTriggerCommand);
 program
     .command('mcp install')
     .alias('mcp-install')
@@ -219,16 +194,9 @@ program
         'Settings',
         '  prave settings                     # configure agents + paths',
         '',
-        'Runs (scheduled cron on Prave)',
-        '  prave run deploy                   # bundle cwd, upload, open wizard',
-        '  prave run update <slug>            # re-upload bundle for an existing run',
-        '  prave run trigger <slug>           # fire one execution outside the cron',
-        '  prave run list                     # your scheduled runs',
-        '  prave run logs <slug>              # tail latest execution log',
-        '',
         'Docs',
         '  prave docs                         # open the docs in your browser',
-        '  prave docs <slug>                  # jump to a section, e.g. cli/run',
+        '  prave docs <slug>                  # jump to a section',
         '',
         'Telemetry',
         '  PRAVE_TELEMETRY=0                  # opt out of CLI usage analytics',
@@ -236,6 +204,19 @@ program
         'Docs:   https://prave.app/docs',
     ].join('\n'));
 });
+// Global first-run banner. Fires once on the user's very first command
+// regardless of which one it was — catches commands that don't have a
+// per-action nudge wired in (e.g. `prave docs`, `prave conflicts`).
+// Per-command `nudgeAfter` calls also invoke `nudgeFirstRun` first, so
+// the once-per-process guard inside the nudge module prevents doubling.
+program.hook('postAction', async () => {
+    try {
+        await nudgeFirstRun();
+    }
+    catch {
+        /* nudges are decorative — never block on them */
+    }
+});
 program.parseAsync().catch((err) => {
     console.error(err.message);
     process.exit(1);

package/dist/lib/nudge-constants.js

@@ -0,0 +1,88 @@
+/**
+ * Centralized copy for every CLI conversion nudge.
+ *
+ * Tuning the funnel = editing this file. The renderer in nudge.ts is dumb
+ * and the wiring in command files is dumb; all the messaging lives here so
+ * a product person can reword without grokking node/chalk.
+ *
+ * Soft nudges = single short pitch under the command output. Strong nudges
+ * = double-line banner with a bulleted value-prop list. Use strong for
+ * commands where the gap between "what they just got locally" and "what
+ * they'd get signed-in" is biggest (overview/whatdoes/first-run).
+ */
+/* --------------------------------------------------------------------- */
+/*  Soft nudges (Nudge 1–4) — throttled to ~1 in every 3 commands.         */
+/* --------------------------------------------------------------------- */
+export const NUDGE_GENERIC = {
+    kind: 'soft',
+    icon: '💡',
+    title: 'Sign in to unlock the full Prave experience',
+    cta: 'prave.app/signup  ·  takes 10 seconds',
+};
+export const NUDGE_LIST = {
+    kind: 'soft',
+    icon: '🔍',
+    title: 'Want AI-generated descriptions for each Skill?',
+    cta: 'Sign in free at prave.app — no credit card needed.',
+};
+export const NUDGE_SEARCH = {
+    kind: 'soft',
+    icon: '🚀',
+    title: 'Unlock semantic search and find Skills by intent.',
+    cta: 'Upgrade to Pro at prave.app — $12/mo',
+};
+export const NUDGE_INSTALL = {
+    kind: 'soft',
+    icon: '📊',
+    title: 'Track token costs and usage for this Skill at prave.app',
+    cta: 'Free account · takes 10 seconds · no credit card',
+};
+/* --------------------------------------------------------------------- */
+/*  Strong nudges (Nudge 5–6) — always shown to unauthenticated users.     */
+/* --------------------------------------------------------------------- */
+export const NUDGE_DEEP = {
+    kind: 'strong',
+    icon: '✨',
+    title: "You're one step away from the full picture.",
+    bullets: [
+        'AI-generated descriptions for all your Skills',
+        'Conflict detection across your library',
+        '30-day usage history from PostToolUse hook',
+        'Cross-machine sync',
+    ],
+    cta: 'prave.app/signup  ·  free forever  ·  10 seconds',
+};
+export const NUDGE_FIRST_RUN = {
+    kind: 'strong',
+    icon: '👋',
+    title: "Welcome to Prave! You're running the CLI — nice.",
+    bullets: [
+        '4,300+ developers are already using it',
+        'Discover 1,200+ Skills with semantic search',
+        'Audit your token footprint',
+        'Sync across all your machines',
+    ],
+    cta: 'prave login      ← connect CLI to your account',
+    ctaSecondary: 'prave.app/signup ← create free account first',
+};
+/** Picks the right variant for a given context. */
+export function nudgeFor(context) {
+    switch (context) {
+        case 'list':
+            return NUDGE_LIST;
+        case 'search':
+            return NUDGE_SEARCH;
+        case 'install':
+            return NUDGE_INSTALL;
+        case 'whatdoes':
+        case 'overview':
+            return NUDGE_DEEP;
+        case 'generic':
+        default:
+            return NUDGE_GENERIC;
+    }
+}
+/** True for nudges that bypass the 1-in-3 throttle. */
+export function isAlwaysShow(context) {
+    return context === 'whatdoes' || context === 'overview';
+}

package/dist/lib/nudge.js

@@ -1,48 +1,157 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import chalk from 'chalk';
+import { CONFIG } from './config.js';
 import { loadCredentials } from './credentials.js';
+import { isAlwaysShow, NUDGE_FIRST_RUN, nudgeFor, } from './nudge-constants.js';
 let alreadyNudged = false;
-export async function nudgeIfAnonymous(context = 'generic') {
+/* --------------------------------------------------------------------- */
+/*  Auth + state helpers                                                  */
+/* --------------------------------------------------------------------- */
+export async function isAuthenticated() {
+    const creds = await loadCredentials();
+    if (!creds?.access_token)
+        return false;
+    // expires_at is unix-seconds. If absent (pre-refresh-token creds) we
+    // assume valid — the API call itself will 401 and trigger re-login.
+    if (typeof creds.expires_at === 'number' && creds.expires_at < Math.floor(Date.now() / 1000)) {
+        return false;
+    }
+    return true;
+}
+async function readConfig() {
+    try {
+        const raw = await readFile(CONFIG.configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object')
+            return parsed;
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+async function writeConfigPatch(patch) {
+    const existing = await readConfig();
+    const next = { ...existing, ...patch };
+    await mkdir(CONFIG.praveDir, { recursive: true, mode: 0o700 });
+    await writeFile(CONFIG.configPath, JSON.stringify(next, null, 2), 'utf8');
+}
+/**
+ * Counter-based throttle for soft nudges. Reads the current count,
+ * increments, persists, and returns true when (count % 3 === 0) — so
+ * roughly every third invocation. The first invocation returns false:
+ * we'd rather skip than be loud on the user's first real command.
+ */
+export async function shouldShowNudge() {
+    const cfg = await readConfig();
+    const current = typeof cfg.nudge_count === 'number' ? cfg.nudge_count : 0;
+    const next = current + 1;
+    await writeConfigPatch({ nudge_count: next });
+    return next % 3 === 0;
+}
+/* --------------------------------------------------------------------- */
+/*  Renderer                                                              */
+/* --------------------------------------------------------------------- */
+function makeRule(char, width = 60) {
+    return char.repeat(width);
+}
+function renderSoft(n) {
+    const rule = chalk.dim(makeRule('─'));
+    const title = chalk.dim(`${n.icon}  ${n.title}`);
+    const cta = chalk.dim(`   ${n.cta}`);
+    return [rule, title, cta, rule].join('\n');
+}
+function renderStrong(n) {
+    const rule = chalk.cyan(makeRule('═'));
+    const title = chalk.bold(`${n.icon}  ${n.title}`);
+    const bullets = n.bullets.map((b) => chalk.dim(`   → ${b}`)).join('\n');
+    const cta = chalk.cyan(`   ${n.cta}`);
+    const cta2 = n.ctaSecondary ? '\n' + chalk.cyan(`   ${n.ctaSecondary}`) : '';
+    return [rule, title, '', bullets, '', cta + cta2, rule].join('\n');
+}
+export function showNudge(nudge) {
+    console.log();
+    console.log(nudge.kind === 'strong' ? renderStrong(nudge) : renderSoft(nudge));
+}
+/* --------------------------------------------------------------------- */
+/*  Public entry points                                                   */
+/* --------------------------------------------------------------------- */
+/**
+ * Gate that all nudge entry points share. Skips when:
+ *   - user is signed in
+ *   - we've already nudged in this process
+ *   - stdout isn't a TTY (pipes, CI)
+ *   - PRAVE_QUIET=1 or PRAVE_TELEMETRY=0 is set
+ */
+async function canNudge() {
     if (alreadyNudged)
-        return;
+        return false;
+    if (!process.stdout.isTTY)
+        return false;
     if (process.env.PRAVE_QUIET === '1')
-        return;
+        return false;
     if (process.env.PRAVE_TELEMETRY === '0')
-        return; // user opted out of analytics
-    // CI / non-interactive shells are unlikely to act on a nudge — and
-    // the noise breaks pipe-parsing scripts.
-    if (!process.stdout.isTTY)
+        return false;
+    if (await isAuthenticated())
+        return false;
+    return true;
+}
+/**
+ * Show the first-run welcome banner if it's the user's very first command
+ * (no nudge_count yet AND first_run not yet set to false). Always strong,
+ * always bypasses the throttle.
+ *
+ * Returns true when shown — call sites use this to skip the regular nudge
+ * on the same turn so we don't double-print.
+ */
+export async function nudgeFirstRun() {
+    if (!(await canNudge()))
+        return false;
+    const cfg = await readConfig();
+    // first_run defaults to "yes, show it" unless we've already flipped
+    // the flag. A missing config file → first run.
+    const alreadyShown = cfg.first_run === false;
+    if (alreadyShown)
+        return false;
+    alreadyNudged = true;
+    showNudge(NUDGE_FIRST_RUN);
+    await writeConfigPatch({ first_run: false });
+    return true;
+}
+/**
+ * Main per-command nudge entry. Pick the most specific context — the
+ * renderer maps it to the matching constant. Strong contexts
+ * (overview/whatdoes) always show; soft ones go through the 1-in-3
+ * throttle.
+ */
+export async function nudgeAfter(context = 'generic') {
+    // First-run handling lives here so every command path picks it up
+    // without needing its own boilerplate. If we showed the welcome banner,
+    // skip the regular nudge for this turn — too noisy otherwise.
+    const showedFirstRun = await nudgeFirstRun();
+    if (showedFirstRun)
+        return;
+    if (!(await canNudge()))
+        return;
+    if (isAlwaysShow(context)) {
+        alreadyNudged = true;
+        showNudge(nudgeFor(context));
+        return;
+    }
+    if (!(await shouldShowNudge()))
         return;
-    const creds = await loadCredentials();
-    if (creds)
-        return; // logged-in → no nudge
     alreadyNudged = true;
-    const cta = chalk.cyan('prave login');
-    const url = chalk.dim('— takes 10 seconds, free forever');
-    const message = (() => {
-        switch (context) {
-            case 'search':
-                return `${chalk.dim('Save these to your library, get token costs + conflicts.')}\n${chalk.dim('→')} ${cta} ${url}`;
-            case 'whatdoes':
-                return `${chalk.dim('Want the full audit — triggers, conflicts, token cost?')}\n${chalk.dim('→')} ${cta} ${url}`;
-            case 'list':
-                return `${chalk.dim('Sign in to see AI descriptions, conflicts and token cost.')}\n${chalk.dim('→')} ${cta} ${url}`;
-            case 'overview':
-                return `${chalk.dim('Track this over time on prave.app.')}\n${chalk.dim('→')} ${cta} ${url}`;
-            case 'generic':
-            default:
-                return `${chalk.dim('Get the full Skill Intelligence on prave.app.')}\n${chalk.dim('→')} ${cta} ${url}`;
-        }
-    })();
-    // One blank line so the nudge isn't glued to the command's main
-    // output. Two `console.log` calls so the chalk styles survive the
-    // pipeline cleanly.
-    console.log();
-    console.log(message);
+    showNudge(nudgeFor(context));
 }
+/**
+ * Back-compat alias. Older call sites used this name; new code should
+ * call `nudgeAfter` directly.
+ */
+export const nudgeIfAnonymous = nudgeAfter;
 /**
  * Post-install banner used by package.json's `postinstall` script.
- * Runs once after `npm i -g @prave/cli`. Stays short — npm's install
- * log is already crowded.
+ * Runs once after `npm i -g @prave/cli`. Kept short — npm's install log
+ * is already crowded.
  */
 export function printPostInstallBanner() {
     if (process.env.CI)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prave/cli",
-  "version": "1.4.6",
+  "version": "1.4.8",
   "description": "Prave CLI — discover, install, version, test, and ship Claude Skills. The developer platform for the complete Skill lifecycle.",
   "type": "module",
   "keywords": [
@@ -54,7 +54,7 @@
     "ora": "^8.0.1",
     "tar": "^7.4.3",
     "undici": "^6.18.0",
-    "@prave/shared": "1.4.6"
+    "@prave/shared": "1.4.8"
   },
   "devDependencies": {
     "@types/node": "^20.12.7",

package/dist/commands/deploy.js

@@ -1,189 +0,0 @@
-/**
- * Multi-agent fan-out helper.
- *
- * This module used to back a public `prave deploy <skill>` command, but
- * shipping that as a top-level CLI surface only duplicated what
- * `prave install` already prompts for ("Deploy to all configured agents?
- * [y/N]"). The standalone command was removed; `deployCommand` lives on
- * as an internal helper that `install.ts` and `sync.ts` import to do
- * the actual fan-out + Cursor `.mdc` rewrite.
- */
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import chalk from 'chalk';
-import ora from 'ora';
-import { AGENT_REGISTRY, compileSkill } from '@prave/shared';
-import { track } from '../lib/analytics.js';
-import { api, ApiError } from '../lib/api.js';
-import { requireAuth } from '../lib/credentials.js';
-import { fetchMyPlan, formatUpgradeHint } from '../lib/plan.js';
-import { CONFIG } from '../lib/config.js';
-import { assertSlug, InvalidSlugError } from '../lib/slug.js';
-import { log } from '../utils/logger.js';
-function detectOsKey(detected) {
-    if (detected === 'windows')
-        return 'windows';
-    // mac + linux both use POSIX paths under "mac" in the registry.
-    return 'mac';
-}
-function expandHome(p, os) {
-    if (os === 'windows')
-        return p;
-    if (p.startsWith('~')) {
-        return join(homedir(), p.slice(1).replace(/^[\\/]/, ''));
-    }
-    return p;
-}
-async function readLocalSkill(slug) {
-    const path = join(CONFIG.skillsDir, slug, 'SKILL.md');
-    try {
-        return await readFile(path, 'utf8');
-    }
-    catch {
-        return null;
-    }
-}
-async function fetchRemoteSkill(slug) {
-    const { data } = await api.get(`/api/v1/skills/${encodeURIComponent(slug)}`, true);
-    if (!data.content) {
-        throw new ApiError(`Remote skill "${slug}" has no content.`, 404);
-    }
-    return data.content;
-}
-/**
- * Build the on-disk write path for the given agent + slug. The
- * `compileSkill()` import from `@prave/shared` decides the *content*
- * transform (e.g. Cursor `.mdc` frontmatter rewrite); this function
- * only resolves the absolute filesystem location by combining the
- * agent's `basePath` from user settings with the relative path the
- * shared compiler returned.
- */
-function buildDestPath(agent, basePath, os, slug, relPath) {
-    const expanded = expandHome(basePath, os);
-    // The shared compiler returns POSIX-style relPaths
-    // (e.g. `<slug>/SKILL.md` or `.cursor/rules/<slug>.mdc`). For
-    // Cursor specifically the user's `basePath` already points at
-    // `.cursor/rules/`, so we collapse the leading `.cursor/rules/`
-    // to avoid the path duplicating to `.cursor/rules/.cursor/rules/`.
-    const collapsed = agent === 'cursor' && relPath.startsWith('.cursor/rules/')
-        ? relPath.slice('.cursor/rules/'.length)
-        : relPath;
-    const file = join(expanded, ...collapsed.split('/'));
-    const dir = file.slice(0, file.length - collapsed.split('/').slice(-1)[0].length - 1);
-    return {
-        dir,
-        file,
-        display: `${basePath.replace(/[\\/]+$/, '')}/${collapsed}`,
-    };
-}
-export async function deployCommand(skillName, opts = {}) {
-    track('cli_deploy', { slug: skillName, agent: opts.agent ?? 'all', dry_run: !!opts.dryRun });
-    try {
-        assertSlug(skillName);
-    }
-    catch (err) {
-        if (err instanceof InvalidSlugError) {
-            log.error(err.message);
-            process.exitCode = 1;
-            return;
-        }
-        throw err;
-    }
-    const session = await requireAuth('prave deploy');
-    if (!session)
-        return;
-    const start = Date.now();
-    // Plan-gate the multi-agent target list. Free can only deploy to
-    // Claude Code; Pro+ unlocks all 6. We compute the allowed set from
-    // PLAN_LIMITS so the Stripe-side and CLI-side stay in lockstep.
-    const me = await fetchMyPlan();
-    const allowedAgents = new Set(me.limits.multi_agent_targets);
-    if (allowedAgents.size === 0) {
-        log.warn(`Your ${me.limits.label} plan can't deploy to any agent.`);
-        log.dim(formatUpgradeHint('explorer'));
-        process.exitCode = 1;
-        return;
-    }
-    let settings;
-    try {
-        const { data } = await api.get('/api/v1/settings/agents', true);
-        settings = data;
-    }
-    catch (err) {
-        log.error(err instanceof ApiError ? err.message : err.message);
-        process.exitCode = 1;
-        return;
-    }
-    const targetFilter = opts.agent && opts.agent.toLowerCase() !== 'all'
-        ? opts.agent.toLowerCase()
-        : null;
-    const targets = settings.enabled_agents
-        .filter((a) => allowedAgents.has(a))
-        .filter((a) => targetFilter === null || a === targetFilter);
-    // If the user picked a target their plan can't reach, tell them why.
-    if (targetFilter && !allowedAgents.has(targetFilter)) {
-        log.warn(`Deploying to ${targetFilter} requires the Pro plan. Free can only deploy to Claude Code.`);
-        log.dim(formatUpgradeHint('explorer'));
-        process.exitCode = 1;
-        return;
-    }
-    if (targets.length === 0) {
-        log.warn('No matching agents enabled. Run `prave settings` to configure.');
-        return;
-    }
-    // Load source content (local first, fall back to remote).
-    let source = await readLocalSkill(skillName);
-    if (!source) {
-        try {
-            source = await fetchRemoteSkill(skillName);
-        }
-        catch (err) {
-            log.error(err instanceof ApiError ? err.message : err.message);
-            process.exitCode = 1;
-            return;
-        }
-    }
-    const os = detectOsKey(settings.detected_os);
-    console.log(`Deploying "${chalk.bold(skillName)}" to ${targets.length} agent${targets.length === 1 ? '' : 's'}${opts.dryRun ? chalk.dim(' (dry-run)') : ''}…`);
-    const spinner = ora('Writing files…').start();
-    let okCount = 0;
-    for (const agent of targets) {
-        const meta = AGENT_REGISTRY[agent];
-        const paths = settings.skill_paths[agent] ?? meta.defaultPath;
-        const basePath = os === 'windows' ? paths.windows : paths.mac;
-        // Shared compileSkill() is the single source of truth — same
-        // function the SaaS /dashboard/compile page calls, so the CLI
-        // and the web zip produce byte-identical output for the same
-        // SKILL.md.
-        const artifact = compileSkill(source, skillName, agent);
-        const dest = buildDestPath(agent, basePath, os, skillName, artifact.path);
-        spinner.text = `→ ${meta.label}`;
-        if (opts.dryRun) {
-            okCount += 1;
-            continue;
-        }
-        try {
-            await mkdir(dest.dir, { recursive: true });
-            await writeFile(dest.file, artifact.content, 'utf8');
-            okCount += 1;
-        }
-        catch (err) {
-            spinner.warn(`Failed: ${meta.label} — ${err.message}`);
-        }
-    }
-    spinner.stop();
-    for (const agent of targets) {
-        const meta = AGENT_REGISTRY[agent];
-        const paths = settings.skill_paths[agent] ?? meta.defaultPath;
-        const basePath = os === 'windows' ? paths.windows : paths.mac;
-        const artifact = compileSkill(source, skillName, agent);
-        const dest = buildDestPath(agent, basePath, os, skillName, artifact.path);
-        const tag = artifact.converted ? chalk.dim(' (converted)') : '';
-        console.log(`${chalk.green('✓')} ${meta.label.padEnd(14)} → ${dest.display}${tag}`);
-    }
-    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
-    console.log(opts.dryRun
-        ? chalk.dim(`Dry-run complete in ${elapsed}s — ${okCount} agents would receive the skill.`)
-        : chalk.dim(`Deployed in ${elapsed}s`));
-}

package/dist/commands/run.js

@@ -1,481 +0,0 @@
-import { readdir, readFile, stat } from 'node:fs/promises';
-import { resolve, relative, basename, sep } from 'node:path';
-import { createInterface } from 'node:readline/promises';
-import { Buffer } from 'node:buffer';
-import chalk from 'chalk';
-import open from 'open';
-import ora from 'ora';
-import * as tar from 'tar';
-import { request } from 'undici';
-import { isLikelyTextPath, scanForSecrets, } from '@prave/shared';
-import { api, ApiError } from '../lib/api.js';
-import { CONFIG } from '../lib/config.js';
-import { loadCredentials, requireAuth } from '../lib/credentials.js';
-import { log } from '../utils/logger.js';
-/**
- * `prave run` — scheduled server-side skill executions on Prave's
- * infrastructure.
- *
- *   prave run deploy [path]       # bundle dir → upload → open wizard
- *   prave run list                # list my deployed runs
- *   prave run logs <slug>         # tail the most recent execution logs
- *
- * `deploy` is the headline action — the rest just expose the same data
- * the dashboard already shows. The wizard handles schedule + agent
- * selection in the browser because picking from an agent dropdown
- * filtered to "which API keys do I have" is way clearer in a UI than
- * an interactive prompt.
- */
-// Sane-default ignore list for `tar.create` — none of these belong in
-// a deployable bundle and dragging them up adds noise to the scan +
-// bloats storage.
-const TAR_IGNORE = new Set([
-    '.git',
-    '.github',
-    '.next',
-    '.turbo',
-    '.svelte-kit',
-    '.cache',
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    '.venv',
-    'venv',
-    '__pycache__',
-    '.DS_Store',
-]);
-const MAX_BUNDLE_BYTES = 20 * 1024 * 1024; // matches API + Supabase Storage cap
-const MAX_FILES = 200;
-export async function runDeployCommand(pathArg, options = {}) {
-    const isUpdate = Boolean(options.updateRunSlug);
-    const root = resolve(pathArg ?? process.cwd());
-    const rootStat = await stat(root).catch(() => null);
-    if (!rootStat?.isDirectory()) {
-        log.error(`Not a directory: ${root}`);
-        process.exit(1);
-    }
-    // Sanity check — the dir should *look* like a skill project. We don't
-    // hard-reject; we just warn if there's no SKILL.md anywhere.
-    const skillMd = await findSkillMd(root);
-    if (!skillMd) {
-        log.warn('No SKILL.md found in this directory. Deploys still work without it, but the runner will not have skill-shaped context for the agent.');
-    }
-    const creds0 = await requireAuth('prave run');
-    if (!creds0)
-        return;
-    // 1a. Look for .env / .env.production / .env.local etc. The scanner
-    // would otherwise hard-reject them on the upload. Offer to lift the
-    // values out of the bundle and pass them to the wizard so they end
-    // up encrypted on the run row instead of in the tarball.
-    const envFiles = await findEnvFiles(root);
-    let envVars = {};
-    const stripPaths = new Set();
-    if (envFiles.length > 0) {
-        const totalKeys = envFiles.reduce((n, f) => n + Object.keys(f.values).length, 0);
-        console.log();
-        console.log(chalk.bold(`Found ${envFiles.length} env file${envFiles.length === 1 ? '' : 's'} with ${totalKeys} variable${totalKeys === 1 ? '' : 's'}:`));
-        for (const f of envFiles) {
-            console.log(`  ${chalk.cyan('•')} ${f.path}  ${chalk.dim(`(${Object.keys(f.values).length} keys)`)}`);
-        }
-        console.log(chalk.dim('\nIf you continue, Prave strips these from the upload and passes the\n' +
-            'values to the browser wizard. They get AES-256-GCM-encrypted onto\n' +
-            'the run, decrypted only inside the sandbox at run-time.\n' +
-            'Decline to abort so you can clean up first.'));
-        const yes = await confirmYesNo('Strip & pass env vars to the wizard?');
-        if (!yes) {
-            log.error('Aborted. Remove the .env file(s) (or rename to .env.example) and re-run.');
-            process.exit(1);
-        }
-        for (const f of envFiles) {
-            stripPaths.add(f.path);
-            Object.assign(envVars, f.values);
-        }
-    }
-    // 1b. Local secret-scan BEFORE we ship anything. Cheap defence in
-    // depth — even though the API scans again, surfacing the finding
-    // pre-upload saves the user a round-trip and avoids briefly storing
-    // a secret-bearing tarball in our bucket. The env files we just
-    // accepted to lift out are excluded from the scan.
-    const localFindings = await preflightScan(root, stripPaths);
-    if (localFindings.length > 0) {
-        log.error('Bundle contains files that look like secrets:');
-        for (const f of localFindings.slice(0, 10)) {
-            console.error(`  ${chalk.red('•')} ${f.rule}  ${chalk.dim(f.path)}${f.line ? `:${f.line}` : ''}`);
-        }
-        console.error(chalk.dim('\nRemove these files (or scrub the values) and re-run.\n' +
-            'For env vars, ship a .env.example template instead — Prave\n' +
-            'will prompt you for the real values during the wizard.'));
-        process.exit(1);
-    }
-    // 2. Mint the deploy session. Update flows tag the session with
-    // the existing run's slug so the upload handler swaps that run's
-    // bundle pointer instead of creating a fresh row.
-    const initSpinner = ora(isUpdate ? `Opening update session for ${options.updateRunSlug}…` : 'Opening deploy session…').start();
-    let session;
-    try {
-        const initPath = isUpdate
-            ? `/api/v1/deploy/init?run_slug=${encodeURIComponent(options.updateRunSlug)}`
-            : '/api/v1/deploy/init';
-        const { data } = await api.post(initPath, {}, true);
-        session = data.session;
-        initSpinner.succeed('Session opened');
-    }
-    catch (err) {
-        initSpinner.fail(`Could not open deploy session: ${err.message}`);
-        process.exit(1);
-    }
-    // 2b. Ship env vars to the wizard before the upload so they're
-    // waiting when the browser opens. The wizard reads them once via
-    // /deploy/status and pre-fills its env-vars step.
-    if (Object.keys(envVars).length > 0) {
-        const envSpinner = ora('Sending env vars to the wizard…').start();
-        try {
-            await api.post(`/api/v1/deploy/env?session=${encodeURIComponent(session.session_id)}`, { env_vars: envVars }, true);
-            envSpinner.succeed(`Passed ${Object.keys(envVars).length} env var(s)`);
-        }
-        catch (err) {
-            envSpinner.fail(`Could not ship env vars: ${err.message}`);
-            process.exit(1);
-        }
-    }
-    // 3. Pack the directory into a gzipped tar in memory. tar.create's
-    // `cwd` option is critical — paths inside the archive must be
-    // RELATIVE to the project root, not absolute. Stripped paths are
-    // env files we already shipped via /deploy/env above.
-    const packSpinner = ora('Bundling project…').start();
-    let tarball;
-    try {
-        tarball = await packDirectory(root, stripPaths);
-        packSpinner.succeed(`Bundled ${formatBytes(tarball.length)}`);
-    }
-    catch (err) {
-        packSpinner.fail(`Bundle failed: ${err.message}`);
-        process.exit(1);
-    }
-    if (tarball.length > MAX_BUNDLE_BYTES) {
-        log.error(`Bundle is ${formatBytes(tarball.length)}, cap is ${formatBytes(MAX_BUNDLE_BYTES)}. ` +
-            'Add large files to .gitignore-style noise (or place them in node_modules / .git which we already skip).');
-        process.exit(1);
-    }
-    // 4. Stream the tarball to /deploy/upload. We use undici directly
-    // because api.ts only does JSON.
-    const uploadSpinner = ora('Uploading to Prave…').start();
-    const creds = await loadCredentials();
-    if (!creds) {
-        uploadSpinner.fail('Credentials expired mid-flight — please re-login.');
-        process.exit(1);
-    }
-    const uploadUrl = `${CONFIG.apiUrl}/api/v1/deploy/upload?session=${encodeURIComponent(session.session_id)}`;
-    try {
-        const { statusCode, body } = await request(uploadUrl, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/gzip',
-                Authorization: `Bearer ${creds.access_token}`,
-            },
-            body: tarball,
-        });
-        const text = await body.text();
-        if (statusCode >= 400) {
-            const parsed = safeJson(text);
-            const msg = parsed?.error ?? `HTTP ${statusCode}`;
-            uploadSpinner.fail(`Upload rejected: ${msg}`);
-            process.exit(1);
-        }
-        uploadSpinner.succeed('Upload complete');
-        // Update flow: the server already swapped the run's bundle
-        // pointer. No wizard, no browser open — just confirm + exit.
-        const parsed = safeJson(text);
-        if (isUpdate || parsed?.updated_run_slug) {
-            console.log();
-            console.log(chalk.bold(`Updated ${parsed?.updated_run_slug ?? options.updateRunSlug}.`));
-            console.log(chalk.dim('  Next scheduled fire will use the freshly-uploaded bundle.\n' +
-                '  Open the dashboard:'));
-            console.log(chalk.cyan('  ' + session.wizard_url));
-            return;
-        }
-    }
-    catch (err) {
-        uploadSpinner.fail(`Upload failed: ${err.message}`);
-        process.exit(1);
-    }
-    // 5. New-run flow: open the browser at the wizard.
-    console.log();
-    console.log(chalk.bold('Finish in the browser:'));
-    console.log(chalk.cyan('  ' + session.wizard_url));
-    try {
-        await open(session.wizard_url);
-    }
-    catch {
-        /* user can copy the URL manually */
-    }
-}
-export async function runListCommand() {
-    if (!(await requireAuth('prave run list')))
-        return;
-    const spinner = ora('Fetching runs…').start();
-    try {
-        const { data } = await api.get('/api/v1/runs', true);
-        spinner.stop();
-        if (!data.runs.length) {
-            console.log(chalk.dim('No runs yet. `prave run deploy` to schedule your first one.'));
-            return;
-        }
-        for (const r of data.runs) {
-            const nextRun = r.next_run_at
-                ? new Date(r.next_run_at).toLocaleString()
-                : chalk.dim('paused');
-            const status = r.status === 'active'
-                ? chalk.green('active')
-                : r.status === 'paused'
-                    ? chalk.yellow('paused')
-                    : chalk.red(r.status);
-            console.log(`  ${chalk.bold(r.name)}  ${chalk.dim(r.slug)}\n` +
-                `    ${chalk.dim(`agent=${r.agent}  schedule=${r.schedule_kind}  status=${status}  next=${nextRun}`)}`);
-        }
-    }
-    catch (err) {
-        spinner.fail(err.message);
-        process.exit(err instanceof ApiError ? 1 : 1);
-    }
-}
-export async function runLogsCommand(slug) {
-    if (!(await requireAuth('prave run logs')))
-        return;
-    const spinner = ora(`Fetching logs for ${slug}…`).start();
-    try {
-        const { data } = await api.get(`/api/v1/runs/${encodeURIComponent(slug)}/executions?limit=10`, true);
-        spinner.stop();
-        if (!data.executions.length) {
-            console.log(chalk.dim('No executions yet. The first one will appear after the next scheduled fire.'));
-            return;
-        }
-        const latest = data.executions[0];
-        const status = latest.status === 'success'
-            ? chalk.green(latest.status)
-            : latest.status === 'running'
-                ? chalk.cyan(latest.status)
-                : chalk.red(latest.status);
-        console.log(`${chalk.bold(slug)}  ${chalk.dim(latest.started_at)}  ${status}` +
-            (latest.duration_ms !== null ? chalk.dim(`  (${latest.duration_ms}ms)`) : ''));
-        console.log();
-        console.log(latest.log_text ?? chalk.dim('(no log captured)'));
-        if (latest.error_message) {
-            console.log();
-            console.log(chalk.red('Error: ') + latest.error_message);
-        }
-    }
-    catch (err) {
-        spinner.fail(err.message);
-        process.exit(1);
-    }
-}
-// ── helpers ──────────────────────────────────────────────────────────
-async function findSkillMd(root) {
-    // Top-level only — most skill projects ship SKILL.md at the root.
-    // Deeper search would be wasted work for the warning we'd print.
-    try {
-        const entries = await readdir(root);
-        return entries.find((n) => n.toLowerCase() === 'skill.md') ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-async function preflightScan(root, stripPaths = new Set()) {
-    const inputs = [];
-    let files = 0;
-    let bytes = 0;
-    const visit = async (dir) => {
-        if (files >= MAX_FILES)
-            return;
-        if (bytes >= MAX_BUNDLE_BYTES)
-            return;
-        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
-        for (const entry of entries) {
-            if (TAR_IGNORE.has(entry.name))
-                continue;
-            if (entry.name.startsWith('._'))
-                continue;
-            const abs = `${dir}${sep}${entry.name}`;
-            if (entry.isDirectory()) {
-                await visit(abs);
-                continue;
-            }
-            if (!entry.isFile())
-                continue;
-            const rel = relative(root, abs).split(sep).join('/');
-            // The user already accepted to lift this env file out of the
-            // bundle in the previous step. Don't scan it (we know it has
-            // secrets — that's why we're lifting it).
-            if (stripPaths.has(rel))
-                continue;
-            files++;
-            if (!isLikelyTextPath(rel)) {
-                inputs.push({ path: rel });
-                continue;
-            }
-            try {
-                const content = await readFile(abs, 'utf8');
-                bytes += content.length;
-                inputs.push({ path: rel, content });
-            }
-            catch {
-                inputs.push({ path: rel });
-            }
-        }
-    };
-    await visit(root);
-    return scanForSecrets(inputs).findings;
-}
-async function packDirectory(root, stripPaths = new Set()) {
-    // Top-level entries only — tar.create resolves them against `cwd`.
-    const entries = (await readdir(root)).filter((n) => !TAR_IGNORE.has(n));
-    if (entries.length === 0) {
-        throw new Error('Project directory is empty.');
-    }
-    // Normalise the strip-set against tar.create's relative-path format
-    // (POSIX forward slashes, no leading "./"). Paths sit one level
-    // beneath the archive's basename prefix, so we compare on the
-    // input-side relative path tar.create hands us.
-    const stripNormalised = new Set([...stripPaths].map((p) => p.replace(/\\/g, '/').replace(/^\.\//, '')));
-    const stream = tar.create({
-        gzip: true,
-        cwd: root,
-        portable: true,
-        // Prefix all paths with the project's basename so the runner
-        // gets a `<project>/SKILL.md` shape, not a flat dump at the
-        // archive root.
-        prefix: basename(root),
-        filter: (path) => {
-            const norm = path.replace(/\\/g, '/').replace(/^\.\//, '');
-            return !stripNormalised.has(norm);
-        },
-    }, entries);
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks);
-}
-/**
- * Look for common `.env*` files at the project root. We don't scan
- * deeper than top-level — a nested `.env` is almost certainly a
- * shipping example, not the real secrets file. Returns an empty list
- * when nothing's found.
- */
-async function findEnvFiles(root) {
-    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
-    const findings = [];
-    for (const entry of entries) {
-        if (!entry.isFile())
-            continue;
-        const name = entry.name;
-        if (!isRealEnvFile(name))
-            continue;
-        try {
-            const raw = await readFile(`${root}${sep}${name}`, 'utf8');
-            const values = parseDotenv(raw);
-            if (Object.keys(values).length === 0)
-                continue;
-            findings.push({ path: name, values });
-        }
-        catch {
-            /* unreadable — skip */
-        }
-    }
-    return findings;
-}
-/**
- * `.env`, `.env.local`, `.env.production`, `.env.development`, `.envrc`
- * count as "real env files". Templates (`.env.example`, `.env.sample`,
- * `.env.template`) are explicitly NOT lifted — those are meant to be
- * shipped.
- */
-function isRealEnvFile(name) {
-    if (name === '.env' || name === '.envrc')
-        return true;
-    if (!name.startsWith('.env.'))
-        return false;
-    const suffix = name.slice('.env.'.length);
-    if (/^(example|sample|template)$/i.test(suffix))
-        return false;
-    return true;
-}
-function parseDotenv(text) {
-    const out = {};
-    for (const raw of text.split('\n')) {
-        const line = raw.trim();
-        if (!line || line.startsWith('#'))
-            continue;
-        const eq = line.indexOf('=');
-        if (eq <= 0)
-            continue;
-        const key = line.slice(0, eq).trim();
-        let value = line.slice(eq + 1).trim();
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
-            out[key] = value;
-    }
-    return out;
-}
-async function confirmYesNo(question) {
-    // Non-interactive shells (pipes, CI) can't prompt — default to "no"
-    // so we never silently ship secrets in a script.
-    if (!process.stdout.isTTY || !process.stdin.isTTY)
-        return false;
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = (await rl.question(`${question} [Y/n] `)).trim().toLowerCase();
-        return answer === '' || answer === 'y' || answer === 'yes';
-    }
-    finally {
-        rl.close();
-    }
-}
-function formatBytes(n) {
-    if (n < 1024)
-        return `${n}B`;
-    if (n < 1024 * 1024)
-        return `${(n / 1024).toFixed(1)}KB`;
-    return `${(n / 1024 / 1024).toFixed(2)}MB`;
-}
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * `prave run trigger <slug>` — fire a single ad-hoc execution outside
- * the cron schedule. Refused with 409 when another execution is in
- * flight (same single-flight guard the dashboard's "Run now" button
- * uses). Returns immediately after enqueueing — tail with
- * `prave run logs <slug>` after a few seconds.
- */
-export async function runTriggerCommand(slug) {
-    if (!(await requireAuth('prave run trigger')))
-        return;
-    const spinner = ora(`Triggering ${slug}…`).start();
-    try {
-        await api.post(`/api/v1/runs/${encodeURIComponent(slug)}/trigger`, undefined, true);
-        spinner.succeed(`Triggered ${chalk.bold(slug)} — log will appear in a few seconds.`);
-        console.log(chalk.dim(`  Tail it with `) +
-            chalk.cyan(`prave run logs ${slug}`) +
-            chalk.dim(` (or watch the dashboard).`));
-    }
-    catch (err) {
-        if (err instanceof ApiError && err.status === 409) {
-            spinner.warn(`An execution is already in flight for ${slug} — wait for it to finish, then re-run.`);
-            return;
-        }
-        spinner.fail(err.message);
-        process.exit(1);
-    }
-}