runwork 0.5.0 → 0.6.0

package/dist/index.js

@@ -23,8 +23,11 @@ import { mcpCommand } from './commands/mcp.js';
 import { setupCommand } from './commands/setup.js';
 import { syncCommand } from './commands/sync.js';
 import { appsCommand } from './commands/apps.js';
+import { doctorCommand } from './commands/doctor.js';
 import { handleGitCredentialRequest } from './git/credentials.js';
 import { VERSION } from './generated/version.js';
+import { shouldOutputJson, jsonOut } from './utils/output.js';
+import { buildHelpJson, buildCommandHelpJson } from './utils/help-json.js';
 const program = new Command();
 program
     .name('runwork')
@@ -56,7 +59,32 @@ program.addCommand(mcpCommand);
 program.addCommand(setupCommand);
 program.addCommand(syncCommand);
 program.addCommand(appsCommand);
+program.addCommand(doctorCommand);
 program.addHelpText('after', '\nFor AI agents: run "runwork info --json" to discover app context and available commands.');
+// JSON help: intercept --help when --json is active or stdout is not a TTY.
+// Outputs the full command tree as structured JSON for AI agents.
+function installJsonHelp(cmd) {
+    cmd.on('beforeHelp', () => {
+        const jsonFlag = cmd.optsWithGlobals?.().json;
+        if (shouldOutputJson(jsonFlag)) {
+            if (cmd === program) {
+                jsonOut(buildHelpJson(program));
+            }
+            else {
+                jsonOut(buildCommandHelpJson(cmd, VERSION));
+            }
+            process.exit(0);
+        }
+    });
+}
+installJsonHelp(program);
+for (const cmd of program.commands) {
+    installJsonHelp(cmd);
+    // Also install on nested subcommands (e.g. `skills list`)
+    for (const sub of cmd.commands) {
+        installJsonHelp(sub);
+    }
+}
 const credentialHelper = program
     .command('git-credential-helper', { hidden: true })
     .argument('<action>', 'Credential action (get/store/erase)')
@@ -74,6 +102,10 @@ const hasCommand = args.some(arg => !arg.startsWith('-') && knownCommands.includ
 if (!hasCommand && !isHelpOrVersion && args.length === 0) {
     const { getCredentials } = await import('./auth/store.js');
     if (!getCredentials()) {
+        if (!process.stdout.isTTY) {
+            console.error('Not logged in. Run `runwork login` first.');
+            process.exit(1);
+        }
         const { runWelcomeWizard } = await import('./commands/welcome.js');
         await runWelcomeWizard();
         process.exit(0);

package/dist/sync/__tests__/change-detect.test.d.ts

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

package/dist/sync/__tests__/change-detect.test.js

@@ -0,0 +1,123 @@
+import { describe, it, expect } from 'vitest';
+import { computeSyncPlan } from '../change-detect.js';
+import { contentHash } from '../hash.js';
+// Helper to build a stored state entry
+function stored(localContent, remoteContent, source = 'external', remoteId, appId) {
+    return {
+        localHash: contentHash(localContent),
+        remoteHash: contentHash(remoteContent),
+        source,
+        remoteId,
+        appId,
+    };
+}
+describe('computeSyncPlan', () => {
+    it('skips when nothing changed', () => {
+        const content = 'skill content unchanged';
+        const plan = computeSyncPlan({
+            storedHashes: { 'my-skill': stored(content, content) },
+            localSkills: [{ name: 'my-skill', content }],
+            remoteSkills: [{ name: 'my-skill', content, source: 'external' }],
+        });
+        expect(plan.skips).toHaveLength(1);
+        expect(plan.skips[0].name).toBe('my-skill');
+        expect(plan.pulls).toHaveLength(0);
+        expect(plan.pushes).toHaveLength(0);
+        expect(plan.conflicts).toHaveLength(0);
+        expect(plan.deletions).toHaveLength(0);
+    });
+    it('pulls when remote changed but local did not', () => {
+        const original = 'original content';
+        const remoteNew = 'remote updated content';
+        const plan = computeSyncPlan({
+            storedHashes: { 'my-skill': stored(original, original) },
+            localSkills: [{ name: 'my-skill', content: original }],
+            remoteSkills: [{ name: 'my-skill', content: remoteNew, source: 'external' }],
+        });
+        expect(plan.pulls).toHaveLength(1);
+        expect(plan.pulls[0].name).toBe('my-skill');
+        expect(plan.pulls[0].action).toBe('pull');
+        expect(plan.pulls[0].remoteContent).toBe(remoteNew);
+        expect(plan.pushes).toHaveLength(0);
+        expect(plan.conflicts).toHaveLength(0);
+    });
+    it('pushes when local changed but remote did not (external skill)', () => {
+        const original = 'original content';
+        const localNew = 'locally updated content';
+        const plan = computeSyncPlan({
+            storedHashes: { 'my-skill': stored(original, original, 'external') },
+            localSkills: [{ name: 'my-skill', content: localNew }],
+            remoteSkills: [{ name: 'my-skill', content: original, source: 'external' }],
+        });
+        expect(plan.pushes).toHaveLength(1);
+        expect(plan.pushes[0].name).toBe('my-skill');
+        expect(plan.pushes[0].action).toBe('push');
+        expect(plan.pushes[0].localContent).toBe(localNew);
+        expect(plan.pulls).toHaveLength(0);
+        expect(plan.conflicts).toHaveLength(0);
+    });
+    it('conflicts when both changed (external skill)', () => {
+        const original = 'original content';
+        const localNew = 'locally updated content';
+        const remoteNew = 'remotely updated content';
+        const plan = computeSyncPlan({
+            storedHashes: { 'my-skill': stored(original, original, 'external') },
+            localSkills: [{ name: 'my-skill', content: localNew }],
+            remoteSkills: [{ name: 'my-skill', content: remoteNew, source: 'external' }],
+        });
+        expect(plan.conflicts).toHaveLength(1);
+        expect(plan.conflicts[0].name).toBe('my-skill');
+        expect(plan.conflicts[0].action).toBe('conflict');
+        expect(plan.conflicts[0].localContent).toBe(localNew);
+        expect(plan.conflicts[0].remoteContent).toBe(remoteNew);
+        expect(plan.pulls).toHaveLength(0);
+        expect(plan.pushes).toHaveLength(0);
+    });
+    it('detects new remote skill (not in stored state)', () => {
+        const content = 'brand new remote skill';
+        const plan = computeSyncPlan({
+            storedHashes: {},
+            localSkills: [],
+            remoteSkills: [{ name: 'new-skill', content, source: 'external', remoteId: 'abc123' }],
+        });
+        expect(plan.pulls).toHaveLength(1);
+        expect(plan.pulls[0].name).toBe('new-skill');
+        expect(plan.pulls[0].action).toBe('new-remote');
+        expect(plan.pulls[0].remoteContent).toBe(content);
+        expect(plan.pulls[0].remoteId).toBe('abc123');
+        expect(plan.pushes).toHaveLength(0);
+        expect(plan.conflicts).toHaveLength(0);
+        expect(plan.deletions).toHaveLength(0);
+    });
+    it('detects deleted remote skill (in stored state, not on workspace)', () => {
+        const content = 'was here before';
+        const plan = computeSyncPlan({
+            storedHashes: { 'gone-skill': stored(content, content, 'external', 'remote-id-1') },
+            localSkills: [{ name: 'gone-skill', content }],
+            remoteSkills: [],
+        });
+        expect(plan.deletions).toHaveLength(1);
+        expect(plan.deletions[0].name).toBe('gone-skill');
+        expect(plan.deletions[0].action).toBe('deleted-remote');
+        expect(plan.pulls).toHaveLength(0);
+        expect(plan.pushes).toHaveLength(0);
+        expect(plan.conflicts).toHaveLength(0);
+    });
+    it('never pushes app skills — local edit on app skill results in pull/overwrite', () => {
+        const original = 'app skill original';
+        const localNew = 'user edited the app skill locally';
+        const appId = 'app-xyz';
+        const plan = computeSyncPlan({
+            storedHashes: { 'app-skill': stored(original, original, 'app', undefined, appId) },
+            localSkills: [{ name: 'app-skill', content: localNew }],
+            remoteSkills: [{ name: 'app-skill', content: original, source: 'app', appId }],
+        });
+        expect(plan.pushes).toHaveLength(0);
+        expect(plan.conflicts).toHaveLength(0);
+        expect(plan.pulls).toHaveLength(1);
+        expect(plan.pulls[0].name).toBe('app-skill');
+        expect(plan.pulls[0].action).toBe('pull');
+        expect(plan.pulls[0].remoteContent).toBe(original);
+        expect(plan.pulls[0].source).toBe('app');
+    });
+});

package/dist/sync/__tests__/hash.test.d.ts

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

package/dist/sync/__tests__/hash.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { contentHash } from '../hash.js';
+describe('contentHash', () => {
+    it('returns sha256-prefixed hash', () => {
+        const hash = contentHash('hello world');
+        expect(hash).toMatch(/^sha256:[a-f0-9]{64}$/);
+    });
+    it('returns same hash for same content', () => {
+        expect(contentHash('test')).toBe(contentHash('test'));
+    });
+    it('returns different hash for different content', () => {
+        expect(contentHash('a')).not.toBe(contentHash('b'));
+    });
+    it('handles empty string', () => {
+        const hash = contentHash('');
+        expect(hash).toMatch(/^sha256:[a-f0-9]{64}$/);
+    });
+});

package/dist/sync/change-detect.d.ts

@@ -0,0 +1,19 @@
+import type { SkillHashState, SyncPlan } from './types.js';
+interface LocalSkill {
+    name: string;
+    content: string;
+}
+interface RemoteSkill {
+    name: string;
+    content: string;
+    source: 'external' | 'app';
+    remoteId?: string;
+    appId?: string;
+}
+interface ComputeSyncInput {
+    storedHashes: Record<string, SkillHashState>;
+    localSkills: LocalSkill[];
+    remoteSkills: RemoteSkill[];
+}
+export declare function computeSyncPlan(input: ComputeSyncInput): SyncPlan;
+export {};

package/dist/sync/change-detect.js

@@ -0,0 +1,136 @@
+import { contentHash } from './hash.js';
+export function computeSyncPlan(input) {
+    const { storedHashes, localSkills, remoteSkills } = input;
+    const plan = {
+        pulls: [],
+        pushes: [],
+        conflicts: [],
+        skips: [],
+        deletions: [],
+    };
+    const localByName = new Map(localSkills.map((s) => [s.name, s]));
+    const remoteByName = new Map(remoteSkills.map((s) => [s.name, s]));
+    // Process all remote skills — new-remote or change-detection
+    for (const remote of remoteSkills) {
+        const stored = storedHashes[remote.name];
+        const local = localByName.get(remote.name);
+        const remoteHash = contentHash(remote.content);
+        if (!stored) {
+            // New remote skill — never seen before
+            plan.pulls.push({
+                name: remote.name,
+                action: 'new-remote',
+                remoteContent: remote.content,
+                source: remote.source,
+                remoteId: remote.remoteId,
+                appId: remote.appId,
+            });
+            continue;
+        }
+        const localHash = local ? contentHash(local.content) : null;
+        const localChanged = localHash !== null && localHash !== stored.localHash;
+        const remoteChanged = remoteHash !== stored.remoteHash;
+        if (!local) {
+            // Local file was deleted — restore from remote
+            plan.pulls.push({
+                name: remote.name,
+                action: 'pull',
+                remoteContent: remote.content,
+                source: remote.source,
+                remoteId: remote.remoteId,
+                appId: remote.appId,
+            });
+            continue;
+        }
+        if (!localChanged && !remoteChanged) {
+            // Nothing changed
+            plan.skips.push({
+                name: remote.name,
+                action: 'skip',
+                source: remote.source,
+                remoteId: remote.remoteId,
+                appId: remote.appId,
+            });
+            continue;
+        }
+        if (!localChanged && remoteChanged) {
+            // Only remote changed
+            plan.pulls.push({
+                name: remote.name,
+                action: 'pull',
+                localContent: local.content,
+                remoteContent: remote.content,
+                source: remote.source,
+                remoteId: remote.remoteId,
+                appId: remote.appId,
+            });
+            continue;
+        }
+        if (localChanged && !remoteChanged) {
+            if (remote.source === 'external') {
+                // Only local changed and skill is external — push
+                plan.pushes.push({
+                    name: remote.name,
+                    action: 'push',
+                    localContent: local.content,
+                    remoteContent: remote.content,
+                    source: remote.source,
+                    remoteId: remote.remoteId,
+                    appId: remote.appId,
+                });
+            }
+            else {
+                // App skill — overwrite local with remote (read-only)
+                plan.pulls.push({
+                    name: remote.name,
+                    action: 'pull',
+                    localContent: local.content,
+                    remoteContent: remote.content,
+                    source: remote.source,
+                    remoteId: remote.remoteId,
+                    appId: remote.appId,
+                });
+            }
+            continue;
+        }
+        // Both changed
+        if (remote.source === 'external') {
+            plan.conflicts.push({
+                name: remote.name,
+                action: 'conflict',
+                localContent: local.content,
+                remoteContent: remote.content,
+                source: remote.source,
+                remoteId: remote.remoteId,
+                appId: remote.appId,
+            });
+        }
+        else {
+            // App skill always wins
+            plan.pulls.push({
+                name: remote.name,
+                action: 'pull',
+                localContent: local.content,
+                remoteContent: remote.content,
+                source: remote.source,
+                remoteId: remote.remoteId,
+                appId: remote.appId,
+            });
+        }
+    }
+    // Process stored skills that no longer exist on remote — deleted remotely
+    for (const [name, stored] of Object.entries(storedHashes)) {
+        if (!remoteByName.has(name)) {
+            const local = localByName.get(name);
+            plan.deletions.push({
+                name,
+                action: 'deleted-remote',
+                localContent: local?.content,
+                source: stored.source,
+                remoteId: stored.remoteId,
+                appId: stored.appId,
+            });
+        }
+    }
+    return plan;
+}

package/dist/sync/conflict-ui.d.ts

@@ -0,0 +1,5 @@
+import type { SyncPlan, SkillSyncAction } from './types.js';
+export declare function printSyncSummary(plan: SyncPlan): void;
+export type ConflictResolution = 'local' | 'remote' | 'skip';
+export declare function resolveConflict(action: SkillSyncAction): Promise<ConflictResolution>;
+export declare function resolveConflictNonInteractive(prefer: 'local' | 'remote'): ConflictResolution;

package/dist/sync/conflict-ui.js

@@ -0,0 +1,78 @@
+import { promptSelect } from '../utils/prompt.js';
+import { bold, dim, cyan, yellow, green } from '../ui/colors.js';
+export function printSyncSummary(plan) {
+    const pullCount = plan.pulls.length;
+    const pushCount = plan.pushes.length;
+    const conflictCount = plan.conflicts.length;
+    const deleteCount = plan.deletions.length;
+    const skipCount = plan.skips.length;
+    console.log('');
+    console.log(bold('Sync summary:') + ` ${pullCount} to pull, ${pushCount} to push, ${conflictCount} conflict${conflictCount !== 1 ? 's' : ''}, ${deleteCount} to delete, ${skipCount} up to date`);
+    console.log('');
+    for (const s of plan.pulls) {
+        const label = s.action === 'new-remote' ? 'new' : 'pull';
+        console.log(`  ${green(`[${label}]`.padEnd(8))} ${s.name.padEnd(28)} ${dim('remote updated')}`);
+    }
+    for (const s of plan.pushes) {
+        console.log(`  ${cyan('[push]'.padEnd(8))} ${s.name.padEnd(28)} ${dim('local changes')}`);
+    }
+    for (const s of plan.conflicts) {
+        console.log(`  ${yellow('[!!]'.padEnd(8))} ${s.name.padEnd(28)} ${dim('modified both locally and remotely')}`);
+    }
+    for (const s of plan.deletions) {
+        console.log(`  ${dim('[del]'.padEnd(8))} ${s.name.padEnd(28)} ${dim('removed from workspace')}`);
+    }
+    console.log('');
+}
+export async function resolveConflict(action) {
+    console.log(`\n${bold(`Conflict: "${action.name}"`)} modified both locally and remotely.\n`);
+    if (action.localContent && action.remoteContent) {
+        const localLines = action.localContent.split('\n').length;
+        const remoteLines = action.remoteContent.split('\n').length;
+        console.log(`  Local:  ${localLines} lines`);
+        console.log(`  Remote: ${remoteLines} lines`);
+        console.log('');
+    }
+    const choice = await promptSelect('Resolution:', [
+        { label: 'Keep local version and push to workspace', value: 'local' },
+        { label: 'Keep remote version and overwrite local', value: 'remote' },
+        { label: 'Show diff', value: 'diff' },
+        { label: 'Skip (resolve later)', value: 'skip' },
+    ]);
+    if (choice.value === 'diff') {
+        printDiff(action.localContent || '', action.remoteContent || '');
+        const choice2 = await promptSelect('After reviewing diff:', [
+            { label: 'Keep local version and push to workspace', value: 'local' },
+            { label: 'Keep remote version and overwrite local', value: 'remote' },
+            { label: 'Skip (resolve later)', value: 'skip' },
+        ]);
+        return choice2.value;
+    }
+    return choice.value;
+}
+function printDiff(local, remote) {
+    const localLines = local.split('\n');
+    const remoteLines = remote.split('\n');
+    const maxLen = Math.max(localLines.length, remoteLines.length);
+    console.log('');
+    console.log(bold('--- Local'));
+    console.log(bold('+++ Remote'));
+    console.log('');
+    for (let i = 0; i < maxLen; i++) {
+        const l = localLines[i];
+        const r = remoteLines[i];
+        if (l === r) {
+            console.log(dim(`  ${l ?? ''}`));
+        }
+        else {
+            if (l !== undefined)
+                console.log(cyan(`- ${l}`));
+            if (r !== undefined)
+                console.log(green(`+ ${r}`));
+        }
+    }
+    console.log('');
+}
+export function resolveConflictNonInteractive(prefer) {
+    return prefer;
+}

package/dist/sync/executor.d.ts

@@ -0,0 +1,21 @@
+import type { ApiClient } from '../api/client.js';
+import type { AgentAdapter } from '../agents/types.js';
+import type { SyncPlan } from './types.js';
+interface ExecutorContext {
+    client: ApiClient;
+    workspaceId: string;
+    adapters: AgentAdapter[];
+    scopes: Array<'project' | 'user'>;
+}
+/**
+ * Execute the resolved sync plan: pull remote skills, push local skills,
+ * delete removed skills. Returns updated skillHashes for state persistence.
+ */
+export declare function executeSyncPlan(plan: SyncPlan, resolvedConflicts: Map<string, 'local' | 'remote'>, ctx: ExecutorContext): Promise<Record<string, {
+    localHash: string;
+    remoteHash: string;
+    source: 'external' | 'app';
+    remoteId?: string;
+    appId?: string;
+}>>;
+export {};

package/dist/sync/executor.js

@@ -0,0 +1,98 @@
+import { contentHash } from './hash.js';
+/**
+ * Execute the resolved sync plan: pull remote skills, push local skills,
+ * delete removed skills. Returns updated skillHashes for state persistence.
+ */
+export async function executeSyncPlan(plan, resolvedConflicts, ctx) {
+    const newHashes = {};
+    // Process pulls
+    for (const action of plan.pulls) {
+        if (!action.remoteContent)
+            continue;
+        const hash = contentHash(action.remoteContent);
+        writeSkillToAgents(action.name, action.remoteContent, ctx);
+        newHashes[action.name] = {
+            localHash: hash,
+            remoteHash: hash,
+            source: action.source,
+            remoteId: action.remoteId,
+            appId: action.appId,
+        };
+        console.log(`  Pulled: ${action.name}`);
+    }
+    // Process pushes
+    for (const action of plan.pushes) {
+        if (!action.localContent || !action.remoteId)
+            continue;
+        await ctx.client.updateExternalSkill(ctx.workspaceId, action.remoteId, {
+            name: action.name,
+            description: extractDescription(action.localContent),
+            content: stripFrontmatter(action.localContent),
+        });
+        const hash = contentHash(action.localContent);
+        newHashes[action.name] = {
+            localHash: hash,
+            remoteHash: hash,
+            source: 'external',
+            remoteId: action.remoteId,
+        };
+        console.log(`  Pushed: ${action.name}`);
+    }
+    // Process resolved conflicts
+    for (const action of plan.conflicts) {
+        const resolution = resolvedConflicts.get(action.name);
+        if (!resolution)
+            continue;
+        if (resolution === 'local' && action.localContent && action.remoteId) {
+            await ctx.client.updateExternalSkill(ctx.workspaceId, action.remoteId, {
+                name: action.name,
+                description: extractDescription(action.localContent),
+                content: stripFrontmatter(action.localContent),
+            });
+            const hash = contentHash(action.localContent);
+            newHashes[action.name] = { localHash: hash, remoteHash: hash, source: 'external', remoteId: action.remoteId };
+            console.log(`  Pushed (conflict resolved): ${action.name}`);
+        }
+        else if (resolution === 'remote' && action.remoteContent) {
+            writeSkillToAgents(action.name, action.remoteContent, ctx);
+            const hash = contentHash(action.remoteContent);
+            newHashes[action.name] = { localHash: hash, remoteHash: hash, source: 'external', remoteId: action.remoteId };
+            console.log(`  Pulled (conflict resolved): ${action.name}`);
+        }
+    }
+    // Process skips -- preserve current state
+    for (const _action of plan.skips) {
+        // Skips don't change hashes -- caller preserves existing state
+    }
+    // Process deletions -- not added to newHashes = removed from state
+    for (const action of plan.deletions) {
+        console.log(`  Deleted locally: ${action.name}`);
+    }
+    return newHashes;
+}
+function writeSkillToAgents(name, content, ctx) {
+    const skillFile = {
+        name,
+        filename: name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+        content,
+        description: extractDescription(content),
+    };
+    for (const adapter of ctx.adapters) {
+        for (const scope of ctx.scopes) {
+            if (!adapter.supportsSkills())
+                continue;
+            try {
+                adapter.writeSkills([skillFile], scope);
+            }
+            catch { /* skip failing adapters */ }
+        }
+    }
+}
+function extractDescription(content) {
+    const match = content.match(/^---\n[\s\S]*?description:\s*(.+)\n[\s\S]*?---/);
+    return match ? match[1].trim() : '';
+}
+function stripFrontmatter(content) {
+    const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
+    return match ? match[1] : content;
+}

package/dist/sync/hash.d.ts

@@ -0,0 +1 @@
+export declare function contentHash(content: string): string;

package/dist/sync/hash.js

@@ -0,0 +1,4 @@
+import { createHash } from 'crypto';
+export function contentHash(content) {
+    return 'sha256:' + createHash('sha256').update(content).digest('hex');
+}

package/dist/sync/types.d.ts

@@ -0,0 +1,24 @@
+export interface SkillHashState {
+    localHash: string;
+    remoteHash: string;
+    source: 'external' | 'app';
+    remoteId?: string;
+    appId?: string;
+}
+export type SkillSyncActionType = 'pull' | 'push' | 'conflict' | 'skip' | 'new-local' | 'new-remote' | 'deleted-remote';
+export interface SkillSyncAction {
+    name: string;
+    action: SkillSyncActionType;
+    localContent?: string;
+    remoteContent?: string;
+    source: 'external' | 'app';
+    remoteId?: string;
+    appId?: string;
+}
+export interface SyncPlan {
+    pulls: SkillSyncAction[];
+    pushes: SkillSyncAction[];
+    conflicts: SkillSyncAction[];
+    skips: SkillSyncAction[];
+    deletions: SkillSyncAction[];
+}

package/dist/sync/types.js

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

package/dist/types.d.ts

@@ -27,6 +27,7 @@ export interface AppInfo {
 export interface WorkspaceInfo {
     id: string;
     name: string;
+    slug?: string;
 }
 export interface RegistryEntity {
     entityName: string;
@@ -93,6 +94,7 @@ export interface WorkspaceSkill {
     type: 'app' | 'external' | 'mcp';
     appId?: string;
     mcpServerId?: string;
+    content?: string;
 }
 export interface ExternalSkillRegistration {
     id: string;
@@ -122,11 +124,21 @@ export interface McpServerConfig {
 export interface SetupState {
     workspaceId: string;
     workspaceName: string;
+    workspaceSlug?: string;
     configuredAgents: string[];
     scope: 'project' | 'user' | 'both';
     lastSyncAt: string;
     mcpServers: string[];
     skills: string[];
+    skillHashes?: Record<string, {
+        localHash: string;
+        remoteHash: string;
+        source: 'external' | 'app';
+        remoteId?: string;
+        appId?: string;
+    }>;
+    reportedAgentSlugs?: string[];
+    lastHealthReportAt?: string;
 }
 export interface WorkflowInfo {
     name: string;

package/dist/ui/__tests__/banner.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { getAgentCommand, SUPPORTED_AGENTS, getDevBanner, getKeyboardHints, getWelcomeBanner, getInfoPanel } from '../banner.js';
 import { stripAnsi } from '../colors.js';
 describe('getAgentCommand', () => {
@@ -80,3 +80,19 @@ describe('getWelcomeBanner', () => {
         expect(text).toContain('Claude');
     });
 });
+describe('runAgentWizard', () => {
+    it('prints guidance text without prompting in non-TTY', async () => {
+        const { runAgentWizard } = await import('../banner.js');
+        const originalIsTTY = process.stdout.isTTY;
+        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        await runAgentWizard('/test/dir');
+        const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+        const plain = stripAnsi(output);
+        expect(plain).toContain('Claude Code');
+        expect(plain).toContain('Cursor');
+        expect(plain).toContain('/test/dir');
+        consoleSpy.mockRestore();
+        Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY, writable: true });
+    });
+});