runwork 0.10.4 → 0.12.0

package/dist/agents/cursor.js

@@ -5,6 +5,39 @@ import { execFileSync } from '../utils/subprocess.js';
 import { querySqlite, openWritableSqlite } from '../utils/sqlite.js';
 import { whichBinary } from '../utils/which.js';
 import { mergeJsonMcpServers, removeRunworkMcpServers, readJsonConfig, writeJsonConfig } from './utils/json-config.js';
+/**
+ * Merge a new managed list into a markerless on-disk array while preserving
+ * user-added entries.
+ *
+ * existing  = what's currently on disk
+ * baseline  = what we wrote on the previous sync (state.lastInjected). Items
+ *             present here are assumed to be ours; subtracting them from
+ *             existing leaves entries the user added themselves.
+ * incoming  = the new managed set to inject (defaults already filtered for
+ *             opt-outs, merged with team rules)
+ *
+ * If baseline is empty (bootstrap or first run with this CLI version), we
+ * assume nothing currently on disk is ours and preserve all existing entries.
+ */
+export function mergeMarkerless(existing, baseline, incoming) {
+    const baselineSet = new Set(baseline);
+    const userEntries = existing.filter((item) => !baselineSet.has(item));
+    const seen = new Set();
+    const result = [];
+    for (const item of userEntries) {
+        if (!seen.has(item)) {
+            seen.add(item);
+            result.push(item);
+        }
+    }
+    for (const item of incoming) {
+        if (!seen.has(item)) {
+            seen.add(item);
+            result.push(item);
+        }
+    }
+    return result;
+}
 export class CursorAdapter {
     name = 'Cursor';
     slug = 'cursor';
@@ -68,7 +101,7 @@ ${skill.content}`;
         writeFileSync(filePath, mdcContent);
     }
     // ── Agent config (model, permissions via SQLite) ────────────────────
-    async writeAgentConfig(config, scope) {
+    async writeAgentConfig(config, scope, baseline) {
         if (scope !== 'user')
             return;
         // Sandbox network allowlist: merge into ~/.cursor/cli-config.json
@@ -108,10 +141,10 @@ ${skill.content}`;
             }
             if (config.permissionRules && data.composerState) {
                 if (config.permissionRules.allow) {
-                    data.composerState.yoloCommandAllowlist = config.permissionRules.allow;
+                    data.composerState.yoloCommandAllowlist = mergeMarkerless(data.composerState.yoloCommandAllowlist ?? [], baseline?.allow ?? [], config.permissionRules.allow);
                 }
                 if (config.permissionRules.deny) {
-                    data.composerState.yoloCommandDenylist = config.permissionRules.deny;
+                    data.composerState.yoloCommandDenylist = mergeMarkerless(data.composerState.yoloCommandDenylist ?? [], baseline?.deny ?? [], config.permissionRules.deny);
                 }
             }
             try {
@@ -125,6 +158,12 @@ ${skill.content}`;
             db.close();
         }
     }
+    async readManagedBlock(_scope) {
+        // Cursor's yoloCommandAllowlist has no marker — there's no way to read a
+        // managed-subset from disk. The sync loop relies on the `baseline` arg
+        // (state.lastInjected) passed into writeAgentConfig instead.
+        return undefined;
+    }
     /**
      * Merge domains into Cursor's sandbox network policy (~/.cursor/sandbox.json).
      * Schema per https://cursor.com/docs/reference/sandbox:

package/dist/agents/default-config.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Baked-in default permission rules that `runwork sync` injects into each
+ * supported agent's configuration.
+ *
+ * Defaults are user-scope only. They merge with team-managed rules from the
+ * workspace admin and are tracked in `~/.runwork/setup.json` under
+ * `agentDefaults[slug]` so that:
+ *   1. Removals stick: if a user deletes an injected entry, it never returns.
+ *   2. Newly added defaults flow in: CLI upgrades that ship more defaults
+ *      auto-apply on the next sync.
+ *   3. Removed defaults disappear: shrinking the set here also removes the
+ *      entries from users' on-disk config on next sync.
+ *   4. Tool removal resets state: `runwork agents remove <slug>` clears the
+ *      per-agent state, so re-adding the tool starts from a clean bootstrap.
+ *
+ * Only agents whose permission model maps cleanly to command-pattern allow/deny
+ * lists appear here. Codex, Gemini, Cline, and Claude Desktop are intentionally
+ * absent (their config formats are toggle-based or tool-name-based and do not
+ * fit). Network domain allowlisting for those agents is handled separately via
+ * AgentConfigOverride.networkAllowlist in sync.ts.
+ */
+export interface BakedDefaults {
+    allow: string[];
+    deny: string[];
+}
+export declare const RUNWORK_AGENT_DEFAULTS: Record<string, BakedDefaults>;
+/** Schema version recorded in setup.json. Bump when default-injection semantics change. */
+export declare const AGENT_DEFAULTS_SCHEMA_VERSION = 1;
+/** Slugs that have baked-in defaults. */
+export declare function hasBakedDefaults(slug: string): boolean;

package/dist/agents/default-config.js

@@ -0,0 +1,67 @@
+/**
+ * Baked-in default permission rules that `runwork sync` injects into each
+ * supported agent's configuration.
+ *
+ * Defaults are user-scope only. They merge with team-managed rules from the
+ * workspace admin and are tracked in `~/.runwork/setup.json` under
+ * `agentDefaults[slug]` so that:
+ *   1. Removals stick: if a user deletes an injected entry, it never returns.
+ *   2. Newly added defaults flow in: CLI upgrades that ship more defaults
+ *      auto-apply on the next sync.
+ *   3. Removed defaults disappear: shrinking the set here also removes the
+ *      entries from users' on-disk config on next sync.
+ *   4. Tool removal resets state: `runwork agents remove <slug>` clears the
+ *      per-agent state, so re-adding the tool starts from a clean bootstrap.
+ *
+ * Only agents whose permission model maps cleanly to command-pattern allow/deny
+ * lists appear here. Codex, Gemini, Cline, and Claude Desktop are intentionally
+ * absent (their config formats are toggle-based or tool-name-based and do not
+ * fit). Network domain allowlisting for those agents is handled separately via
+ * AgentConfigOverride.networkAllowlist in sync.ts.
+ */
+export const RUNWORK_AGENT_DEFAULTS = {
+    'claude-code': {
+        allow: [
+            'Bash(runwork *)',
+            'Bash(runwork-cli *)',
+            'Bash(git status)',
+            'Bash(git diff:*)',
+            'Bash(git log:*)',
+            'Bash(git branch:*)',
+            'Bash(git show:*)',
+            'Bash(ls:*)',
+            'Bash(pwd)',
+            'Bash(cat:*)',
+        ],
+        deny: [
+            'Bash(rm -rf *)',
+            'Bash(rm -rf /*)',
+            'Bash(sudo rm *)',
+        ],
+    },
+    'cursor': {
+        allow: [
+            'runwork',
+            'runwork *',
+            'runwork-cli',
+            'runwork-cli *',
+            'git status',
+            'git diff',
+            'git log',
+            'git branch',
+            'ls',
+            'pwd',
+            'cat',
+        ],
+        deny: [
+            'rm -rf *',
+            'sudo *',
+        ],
+    },
+};
+/** Schema version recorded in setup.json. Bump when default-injection semantics change. */
+export const AGENT_DEFAULTS_SCHEMA_VERSION = 1;
+/** Slugs that have baked-in defaults. */
+export function hasBakedDefaults(slug) {
+    return slug in RUNWORK_AGENT_DEFAULTS;
+}

package/dist/agents/defaults-merge.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Pure functions for the default-rules merge algorithm.
+ *
+ * The sync loop (commands/sync.ts) wires these together with per-adapter I/O.
+ * Keeping the logic side-effect-free here makes it cheap to unit-test the
+ * tricky lifecycle (bootstrap, opt-out detection, set shrinking) without
+ * mocking filesystem layers.
+ */
+import type { AgentDefaultsState } from '../types.js';
+import type { BakedDefaults } from './default-config.js';
+/** Items present in `lastInjected` but not in `onDisk`. These are entries the user removed since the previous sync. */
+export declare function detectRemovals(lastInjected: string[], onDisk: string[]): string[];
+/** Defaults filtered to exclude anything the user has opted out of. */
+export declare function computeApplicable(baked: string[], optOuts: string[]): string[];
+/**
+ * Dedupe-silently merge of defaults and team rules. Team rules appear after
+ * defaults in the output (the marker block's team-managed half), and dedupe
+ * keeps the team-positioned copy when a default and a team rule are identical
+ * strings. Stable ordering is preserved.
+ */
+export declare function mergeAllow(applicableDefaults: string[], teamRules: string[]): string[];
+export declare function unique(items: string[]): string[];
+/** True if no per-agent state has ever been recorded — first sync after upgrade or fresh install. */
+export declare function isBootstrap(state: AgentDefaultsState | undefined): boolean;
+export interface ResolveResult {
+    /**
+     * Final merged list to write into the managed block.
+     * For marker-based agents (Claude Code): goes after the marker.
+     * For markerless agents (Cursor): becomes part of the array,
+     * with `baseline` used by the adapter to identify and preserve user entries.
+     */
+    managedAllow: string[];
+    managedDeny: string[];
+    /** Defaults that we actually injected this sync. Stored as next sync's lastInjected. */
+    applicableAllow: string[];
+    applicableDeny: string[];
+    /** New sticky opt-out set. Stored as next sync's userOptOuts. */
+    newOptOutsAllow: string[];
+    newOptOutsDeny: string[];
+    /** Diagnostic counts for the sync log. */
+    removalsThisSync: {
+        allow: number;
+        deny: number;
+    };
+    /** True when this sync is the bootstrap pass and skipped default injection. */
+    bootstrapped: boolean;
+}
+export interface ResolveInput {
+    baked: BakedDefaults | undefined;
+    state: AgentDefaultsState | undefined;
+    onDisk: {
+        allow?: string[];
+        deny?: string[];
+    } | undefined;
+    team: {
+        allow?: string[];
+        deny?: string[];
+    } | undefined;
+}
+/**
+ * Single-call resolver for one agent. Consumes the full input set and emits
+ * the merged managed lists plus the next-sync state values. Pure: no I/O.
+ *
+ * Cases:
+ *   1. No baked defaults for this agent → emits team rules only (no defaults
+ *      logic kicks in). State stays undefined.
+ *   2. Bootstrap (state undefined) → applies team rules but does NOT inject
+ *      defaults this sync. Caller initializes empty state for next time.
+ *   3. Normal → detects removals against lastInjected, accumulates opt-outs,
+ *      filters baked by opt-outs, merges with team rules.
+ */
+export declare function resolveAgentDefaults(input: ResolveInput): ResolveResult;

package/dist/agents/defaults-merge.js

@@ -0,0 +1,131 @@
+/**
+ * Pure functions for the default-rules merge algorithm.
+ *
+ * The sync loop (commands/sync.ts) wires these together with per-adapter I/O.
+ * Keeping the logic side-effect-free here makes it cheap to unit-test the
+ * tricky lifecycle (bootstrap, opt-out detection, set shrinking) without
+ * mocking filesystem layers.
+ */
+/** Items present in `lastInjected` but not in `onDisk`. These are entries the user removed since the previous sync. */
+export function detectRemovals(lastInjected, onDisk) {
+    const onDiskSet = new Set(onDisk);
+    return lastInjected.filter((item) => !onDiskSet.has(item));
+}
+/** Defaults filtered to exclude anything the user has opted out of. */
+export function computeApplicable(baked, optOuts) {
+    const optOutSet = new Set(optOuts);
+    return baked.filter((item) => !optOutSet.has(item));
+}
+/**
+ * Dedupe-silently merge of defaults and team rules. Team rules appear after
+ * defaults in the output (the marker block's team-managed half), and dedupe
+ * keeps the team-positioned copy when a default and a team rule are identical
+ * strings. Stable ordering is preserved.
+ */
+export function mergeAllow(applicableDefaults, teamRules) {
+    const teamSet = new Set(teamRules);
+    const result = [];
+    for (const item of applicableDefaults) {
+        if (!teamSet.has(item))
+            result.push(item);
+    }
+    for (const item of teamRules) {
+        result.push(item);
+    }
+    return result;
+}
+export function unique(items) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        if (!seen.has(item)) {
+            seen.add(item);
+            out.push(item);
+        }
+    }
+    return out;
+}
+/** True if no per-agent state has ever been recorded — first sync after upgrade or fresh install. */
+export function isBootstrap(state) {
+    return state === undefined;
+}
+/**
+ * Single-call resolver for one agent. Consumes the full input set and emits
+ * the merged managed lists plus the next-sync state values. Pure: no I/O.
+ *
+ * Cases:
+ *   1. No baked defaults for this agent → emits team rules only (no defaults
+ *      logic kicks in). State stays undefined.
+ *   2. Bootstrap (state undefined) → applies team rules but does NOT inject
+ *      defaults this sync. Caller initializes empty state for next time.
+ *   3. Normal → detects removals against lastInjected, accumulates opt-outs,
+ *      filters baked by opt-outs, merges with team rules.
+ */
+export function resolveAgentDefaults(input) {
+    const team = input.team ?? {};
+    const teamAllow = team.allow ?? [];
+    const teamDeny = team.deny ?? [];
+    // Case 1: no baked defaults — emit team rules unchanged, no state to track.
+    if (!input.baked) {
+        return {
+            managedAllow: unique(teamAllow),
+            managedDeny: unique(teamDeny),
+            applicableAllow: [],
+            applicableDeny: [],
+            newOptOutsAllow: [],
+            newOptOutsDeny: [],
+            removalsThisSync: { allow: 0, deny: 0 },
+            bootstrapped: false,
+        };
+    }
+    // Case 2: bootstrap — do not inject defaults this pass.
+    if (isBootstrap(input.state)) {
+        return {
+            managedAllow: unique(teamAllow),
+            managedDeny: unique(teamDeny),
+            applicableAllow: [],
+            applicableDeny: [],
+            newOptOutsAllow: [],
+            newOptOutsDeny: [],
+            removalsThisSync: { allow: 0, deny: 0 },
+            bootstrapped: true,
+        };
+    }
+    // Case 3: normal merge.
+    const state = input.state;
+    const lastInjectedAllow = state.lastInjected.allow ?? [];
+    const lastInjectedDeny = state.lastInjected.deny ?? [];
+    const existingOptOutsAllow = state.userOptOuts.allow ?? [];
+    const existingOptOutsDeny = state.userOptOuts.deny ?? [];
+    // Removal detection requires a reliable on-disk read. Markerless adapters
+    // (Cursor) cannot distinguish injected entries from user entries on disk, so
+    // they return `undefined` from readManagedBlock. Treating `undefined` as an
+    // empty array would fabricate a "user removed everything" signal on every
+    // subsequent sync and incorrectly convert every default into a sticky opt-out.
+    // When we cannot read managed state, we trust the baseline mechanism in the
+    // adapter and skip removal detection for this sync.
+    const canDetectRemovals = input.onDisk !== undefined;
+    const newRemovalsAllow = canDetectRemovals
+        ? detectRemovals(lastInjectedAllow, input.onDisk?.allow ?? [])
+        : [];
+    const newRemovalsDeny = canDetectRemovals
+        ? detectRemovals(lastInjectedDeny, input.onDisk?.deny ?? [])
+        : [];
+    const newOptOutsAllow = unique([...existingOptOutsAllow, ...newRemovalsAllow]);
+    const newOptOutsDeny = unique([...existingOptOutsDeny, ...newRemovalsDeny]);
+    const applicableAllow = computeApplicable(input.baked.allow, newOptOutsAllow);
+    const applicableDeny = computeApplicable(input.baked.deny, newOptOutsDeny);
+    return {
+        managedAllow: mergeAllow(applicableAllow, teamAllow),
+        managedDeny: mergeAllow(applicableDeny, teamDeny),
+        applicableAllow,
+        applicableDeny,
+        newOptOutsAllow,
+        newOptOutsDeny,
+        removalsThisSync: {
+            allow: newRemovalsAllow.length,
+            deny: newRemovalsDeny.length,
+        },
+        bootstrapped: false,
+    };
+}

package/dist/agents/intro-skill.d.ts

@@ -22,6 +22,15 @@ export interface InstructionHintContext {
     appCount: number;
     skillCount: number;
     mcpServerCount: number;
+    /**
+     * Technical-level classification from desktop onboarding. When present,
+     * a persona-specific communication block is added to the instruction hint
+     * so integrated agents match the user's experience level.
+     */
+    persona?: {
+        level: 1 | 2 | 3;
+        label: 'novice' | 'curious' | 'engineer';
+    };
 }
 export declare function buildAppSkillDescription(appName: string, registries: WorkspaceAllData | null): string;
 /**

package/dist/agents/intro-skill.js

@@ -1,3 +1,37 @@
+/**
+ * Build a persona-specific communication block for the instruction hint.
+ * Returns an empty array for engineers (level 3), who need no special tone
+ * handling, and for an absent/unknown persona.
+ */
+function buildPersonaBlock(persona) {
+    if (!persona || persona.level === 3)
+        return [];
+    if (persona.level === 1) {
+        return [
+            '',
+            '### Communicating with this user',
+            '',
+            'The person you are helping is new to AI tools and is not a software developer. Adapt how you work with them:',
+            '',
+            '- Explain things in plain, everyday language. Do not assume they know programming or technical concepts.',
+            '- Do not ask them to run developer tooling (npm, bun, node, pnpm, yarn, git, build or package-manager commands). When a task needs technical steps, perform those steps yourself instead of instructing the user.',
+            '- Avoid jargon. When a technical term is unavoidable, define it in one short sentence.',
+            '- Work in small steps. Do one thing, confirm it landed, then continue.',
+            '- Focus on what the user wants to accomplish, not on the implementation details.',
+        ];
+    }
+    // Level 2: curious
+    return [
+        '',
+        '### Communicating with this user',
+        '',
+        'The person you are helping has some familiarity with AI tools but is not a professional developer. Adapt how you work with them:',
+        '',
+        '- Prefer plain language. When you use a technical term, briefly explain what it means.',
+        '- Do not lean on developer tooling (npm, bun, node, git, build commands) unless it is genuinely required, and explain what any command does before suggesting it.',
+        '- Keep explanations concise and outcome-focused.',
+    ];
+}
 /** Format a list of names with truncation. Shows up to `max` items, then "+ N more". */
 function formatList(items, max = 8) {
     if (items.length <= max)
@@ -314,6 +348,12 @@ export function generateIntroSkill(ctx) {
     lines.push('- Every workflow needs a trigger (endpoint, schedule, or UI button).');
     lines.push('- Use `search_available_integrations` MCP tool or `runwork integrations search <query>` before adding integrations, never guess IDs.');
     lines.push('');
+    lines.push('**Environment variables and secrets:** Runwork apps do NOT have a custom environment variable or secrets system.');
+    lines.push('- You cannot add your own keys to a `.env` file, define `process.env.MY_KEY`, or configure per-app secrets. Do not write code that depends on custom env vars, and do not tell the user to create `.env` files or set secrets.');
+    lines.push('- A fixed set of platform variables is injected automatically by `@runworkai/framework` (workspace identifiers, AI proxy, integration proxy). You do not set these and should not hardcode or depend on their exact names.');
+    lines.push('- For configuration values or API keys you need to store, use a dedicated entity with an app-specific name (for example `AcmeCrmConfig`, not a generic `Config` or `AppConfig`, which would collide with other apps in the workspace) and read it at runtime, not env vars.');
+    lines.push('- For third-party API access, use connected Runwork integrations (`{id}_api` MCP tools); they handle authentication without secrets in your code.');
+    lines.push('');
     // Capability reference — detailed mapping of needs to Runwork capabilities.
     // The "Default Actions" section at the top handles routing; this is the
     // longer reference for when the agent wants to understand what's available.
@@ -399,6 +439,7 @@ export function generateInstructionHint(ctx) {
         `**Available now:** ${inventory}`,
         '',
         `Runwork MCP tools are always connected -- use them for data access, integration API calls, skill management, and resource discovery.${integrationToolHint} Use \`runwork\` CLI to create (\`runwork init\`), develop (\`runwork dev\`), and deploy (\`runwork deploy\`) apps. Install CLI: \`curl -fsSL https://runwork.ai/install.sh | sh\`. Web dashboard: ${dashboardUrl}. Invoke the \`runwork\` skill for full capability reference.`,
+        ...buildPersonaBlock(ctx.persona),
         '<!-- runwork:end -->',
     ].join('\n');
 }

package/dist/agents/types.d.ts

@@ -33,8 +33,37 @@ export interface AgentAdapter {
     mcpProvidesSkills?: boolean;
     /** Write team-managed instructions (separate marker block from auto-generated hint) */
     writeTeamInstructions?(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    /** Write agent-specific config overrides from workspace admin (model, permissions) */
-    writeAgentConfig?(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
+    /**
+     * Write agent-specific config overrides from workspace admin (model, permissions).
+     *
+     * @param config - The full resolved config to apply this sync (already merged
+     *   with baked defaults and network/minimum settings by the sync loop).
+     * @param scope - Project- or user-scope configuration target.
+     * @param baseline - Optional. The set of managed entries the previous sync
+     *   wrote (lastInjected from setup.json). Adapters that lack on-disk markers
+     *   to distinguish runwork-managed entries from user-added entries (e.g.
+     *   Cursor's yoloCommandAllowlist) use this to subtract our previous
+     *   contribution before re-injecting, preserving user edits. Marker-based
+     *   adapters (Claude Code) can ignore this parameter.
+     */
+    writeAgentConfig?(config: AgentConfigOverride, scope: 'project' | 'user', baseline?: {
+        allow?: string[];
+        deny?: string[];
+    }): Promise<void>;
+    /**
+     * Read the currently-injected managed-block entries for this scope.
+     * Used by sync to detect when the user has removed an entry that we
+     * previously injected (so we can record it as a sticky opt-out).
+     *
+     * For marker-based adapters (Claude Code): returns items after the marker.
+     * For markerless adapters (Cursor): may return undefined; the sync loop
+     * falls back to the `baseline` mechanism (state.lastInjected) for those.
+     * Optional — adapters without a permission file at all (Cline) skip this.
+     */
+    readManagedBlock?(scope: 'project' | 'user'): Promise<{
+        allow?: string[];
+        deny?: string[];
+    } | undefined>;
     /** Remove all Runwork-managed config, skills, MCP entries, and instruction hints.
      *  The manifest lists exactly which resources were synced so only those are removed. */
     cleanup?(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;

package/dist/commands/__tests__/setup-persona.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/setup-persona.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { resolvePersona } from '../setup.js';
+/**
+ * resolvePersona decides what persona ends up in setup.json. The `--persona`
+ * flag (set by the desktop onboarding flow) wins; otherwise an existing persona
+ * on disk is preserved so a manual `runwork setup` re-run does not wipe it.
+ */
+describe('resolvePersona', () => {
+    it('maps a valid --persona flag to level and label', () => {
+        expect(resolvePersona('1', undefined)).toEqual({ level: 1, label: 'novice' });
+        expect(resolvePersona('2', undefined)).toEqual({ level: 2, label: 'curious' });
+        expect(resolvePersona('3', undefined)).toEqual({ level: 3, label: 'engineer' });
+    });
+    it('preserves the existing persona when no flag is given', () => {
+        const existing = { level: 2, label: 'curious' };
+        expect(resolvePersona(undefined, existing)).toEqual(existing);
+    });
+    it('falls back to the existing persona for an invalid flag', () => {
+        const existing = { level: 3, label: 'engineer' };
+        expect(resolvePersona('99', existing)).toEqual(existing);
+        expect(resolvePersona('abc', existing)).toEqual(existing);
+        expect(resolvePersona('0', existing)).toEqual(existing);
+    });
+    it('returns undefined when there is no flag and nothing on disk', () => {
+        expect(resolvePersona(undefined, undefined)).toBeUndefined();
+    });
+    it('prefers the flag over an existing on-disk persona', () => {
+        const existing = { level: 1, label: 'novice' };
+        expect(resolvePersona('3', existing)).toEqual({ level: 3, label: 'engineer' });
+    });
+});

package/dist/commands/info.d.ts

@@ -121,7 +121,7 @@ interface InfoOutput {
      */
     localDevSession: LocalDevState;
     production: {
-        url: null;
+        url: string | null;
         deployed: boolean;
     };
     integrations: Array<{

package/dist/commands/info.js

@@ -239,7 +239,12 @@ function printHumanOutput(data) {
         else {
             console.log(`  ${dim(pad('Preview:'))}${dim('(not running)')}`);
         }
-        console.log(`  ${dim(pad('Production:'))}${dim('(not available)')}`);
+        if (data.production.url) {
+            console.log(`  ${dim(pad('Production:'))}${green(data.production.url)} ${dim('(deployed)')}`);
+        }
+        else {
+            console.log(`  ${dim(pad('Production:'))}${dim('(not deployed)')}`);
+        }
         // Local dev session view: what's running on THIS machine, from the
         // session file. This may disagree with the server's "preview"
         // status above; that's diagnostic, not a bug.
@@ -422,7 +427,7 @@ export const infoCommand = new Command('info')
         },
         preview,
         localDevSession,
-        production: { url: null, deployed: false },
+        production: appInfo?.production ?? { url: null, deployed: false },
         integrations,
         registries,
         cli: {

package/dist/commands/setup.d.ts

@@ -1,5 +1,12 @@
 import { Command } from 'commander';
 import { ApiClient } from '../api/client.js';
+import type { SetupState } from '../types.js';
+/**
+ * Resolve the persona to persist in setup.json. Prefers the `--persona` flag
+ * (passed by the desktop onboarding flow); otherwise preserves any persona
+ * already on disk so re-running `setup` without the flag does not wipe it.
+ */
+export declare function resolvePersona(flag: string | undefined, existing: SetupState['persona']): SetupState['persona'];
 /**
  * Resolve the workspace for `setup` and persist it as the default in credentials.
  *

package/dist/commands/setup.js

@@ -8,6 +8,26 @@ import { resolveWorkspace, hasProjectConfig } from '../workspace/resolve.js';
 import { promptSelect, promptConfirm } from '../utils/prompt.js';
 import { detectAgents, printNoAgentsMessage } from '../agents/detect.js';
 import { syncFromState } from './sync.js';
+import { loadSetupState } from '../utils/setup-state.js';
+const PERSONA_LABELS = {
+    1: 'novice',
+    2: 'curious',
+    3: 'engineer',
+};
+/**
+ * Resolve the persona to persist in setup.json. Prefers the `--persona` flag
+ * (passed by the desktop onboarding flow); otherwise preserves any persona
+ * already on disk so re-running `setup` without the flag does not wipe it.
+ */
+export function resolvePersona(flag, existing) {
+    if (flag) {
+        const level = Number(flag);
+        if (level === 1 || level === 2 || level === 3) {
+            return { level, label: PERSONA_LABELS[level] };
+        }
+    }
+    return existing;
+}
 /**
  * Resolve the workspace for `setup` and persist it as the default in credentials.
  *
@@ -49,6 +69,7 @@ export const setupCommand = new Command('setup')
     .option('--agent <slug>', 'Only configure a specific agent (e.g. claude-code, cursor)')
     .option('--dry-run', 'Show what would be configured without writing files')
     .option('-y, --yes', 'Skip all prompts, configure all detected agents with user scope')
+    .option('--persona <level>', 'Technical-level persona for agent instructions (1=novice, 2=curious, 3=engineer)')
     .action(async (opts) => {
     const credentials = requireAuth();
     const client = new ApiClient(credentials);
@@ -124,6 +145,7 @@ export const setupCommand = new Command('setup')
         skills: [],
         skillHashes: {},
         lastDetectedAt: new Date().toISOString(),
+        persona: resolvePersona(opts.persona, loadSetupState()?.persona),
     };
     const scopes = scope === 'both' ? ['project', 'user'] : [scope];
     for (const s of scopes) {