runwork 0.2.5 → 0.3.0

package/dist/auth/login-flow.d.ts

@@ -0,0 +1,10 @@
+import type { Credentials } from '../types.js';
+/**
+ * Performs the full browser-based login flow:
+ * 1. Initiates login, opens browser
+ * 2. Polls for completion
+ * 3. Saves credentials and configures git
+ *
+ * Returns the credentials on success, exits process on timeout.
+ */
+export declare function performLogin(baseUrl?: string): Promise<Credentials>;

package/dist/auth/login-flow.js

@@ -0,0 +1,37 @@
+import { ApiClient } from '../api/client.js';
+import { saveCredentials } from './store.js';
+import { configureGitCredentials } from '../git/credentials.js';
+const DEFAULT_BASE_URL = 'https://runwork.ai';
+/**
+ * Performs the full browser-based login flow:
+ * 1. Initiates login, opens browser
+ * 2. Polls for completion
+ * 3. Saves credentials and configures git
+ *
+ * Returns the credentials on success, exits process on timeout.
+ */
+export async function performLogin(baseUrl) {
+    const url = baseUrl || DEFAULT_BASE_URL;
+    const client = new ApiClient({ apiKey: '', email: '', baseUrl: url });
+    const { sessionId, loginUrl } = await client.initiateLogin();
+    // Open browser
+    const open = await import('open');
+    await open.default(loginUrl);
+    console.log(`If browser didn't open, visit: ${loginUrl}`);
+    console.log('');
+    console.log('Waiting for authentication...');
+    const maxAttempts = 60;
+    const pollInterval = 5000;
+    for (let i = 0; i < maxAttempts; i++) {
+        await new Promise(resolve => setTimeout(resolve, pollInterval));
+        const result = await client.pollLogin(sessionId);
+        if (result) {
+            saveCredentials(result);
+            await configureGitCredentials(result.baseUrl || url);
+            console.log(`Logged in as ${result.email}`);
+            return result;
+        }
+    }
+    console.error('Login timed out. Please try again.');
+    process.exit(1);
+}

package/dist/commands/clone.d.ts

@@ -1,2 +1,5 @@
 import { Command } from 'commander';
+import { ApiClient } from '../api/client.js';
+import type { AppInfo } from '../types.js';
+export declare function execClone(client: ApiClient, app: AppInfo, directory?: string): Promise<string>;
 export declare const cloneCommand: Command;

package/dist/commands/clone.js

@@ -1,37 +1,18 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { promptSelect } from '../utils/prompt.js';
 import { generateManifest, saveManifest } from '../template/manifest.js';
 import { extractZip } from '../utils/zip.js';
 import { removeNestedGitDirs } from '../utils/fs.js';
-export const cloneCommand = new Command('clone')
-    .description('Clone a Runwork app to local development')
-    .argument('[appId]', 'App ID to clone (interactive if omitted)')
-    .argument('[directory]', 'Target directory')
-    .action(async (appId, directory) => {
-    const creds = requireAuth();
-    const client = new ApiClient(creds);
-    let app;
-    if (appId) {
-        app = await client.getApp(appId);
-    }
-    else {
-        const apps = await client.listApps();
-        if (apps.length === 0) {
-            console.error('No apps found.');
-            process.exit(1);
-        }
-        const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
-        app = choice.value;
-    }
+import { runAgentWizard } from '../ui/banner.js';
+export async function execClone(client, app, directory) {
     const slug = app.slug || app.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const dir = directory || slug;
     const remoteUrl = client.getGitRemoteUrl(app.workspaceId, app.id);
-    console.log(`Cloning "${app.name}"...`);
     // Step 1: Extract skeleton template as the base layer
     console.log('Downloading project template...');
     mkdirSync(dir, { recursive: true });
@@ -70,6 +51,7 @@ export const cloneCommand = new Command('clone')
     // Write .runwork.json config
     const config = {
         workspaceId: app.workspaceId,
+        workspaceName: app.workspaceName,
         appId: app.id,
         appName: app.name,
     };
@@ -85,6 +67,32 @@ export const cloneCommand = new Command('clone')
         // App may be new with no registries yet
     }
     console.log(`\nApp "${app.name}" cloned to ${dir}/`);
-    console.log(`Remote: ${remoteUrl}`);
-    console.log(`\nNext: cd ${dir} && runwork dev`);
+    console.log(`Remote: ${client.getGitRemoteUrl(app.workspaceId, app.id)}`);
+    return resolve(dir);
+}
+export const cloneCommand = new Command('clone')
+    .description('Clone a Runwork app to local development')
+    .argument('[appId]', 'App ID to clone (interactive if omitted)')
+    .argument('[directory]', 'Target directory')
+    .action(async (appId, directory) => {
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    let app;
+    if (appId) {
+        app = await client.getApp(appId);
+    }
+    else {
+        const apps = await client.listApps();
+        if (apps.length === 0) {
+            console.error('No apps found.');
+            process.exit(1);
+        }
+        const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
+        app = choice.value;
+    }
+    console.log(`Cloning "${app.name}"...`);
+    const dir = await execClone(client, app, directory);
+    const slug = dir.split('/').pop() || dir;
+    await runAgentWizard(dir);
+    console.log(`Next: cd ${slug} && runwork dev`);
 });

package/dist/commands/dev.d.ts

@@ -1,2 +1,6 @@
 import { Command } from 'commander';
+export declare function execDev(options?: {
+    logs?: boolean;
+    logsOnlyFile?: boolean;
+}): Promise<void>;
 export declare const devCommand: Command;

package/dist/commands/dev.js

@@ -11,6 +11,10 @@ import { populateTypes } from '../types-manager.js';
 import { loadManifest, generateManifest, saveManifest, detectUserEdits } from '../template/manifest.js';
 import { extractZip } from '../utils/zip.js';
 import { removeNestedGitDirs } from '../utils/fs.js';
+import { getDevBanner, getKeyboardHints, getInfoPanel } from '../ui/banner.js';
+import { createStatusLine } from '../ui/status-line.js';
+import { createKeyboardListener } from '../ui/keyboard.js';
+import { bold, dim, green, yellow, cyan } from '../ui/colors.js';
 async function populateSkill(projectDir, client, appId) {
     try {
         const { skill } = await client.getAppSkill(appId);
@@ -29,11 +33,7 @@ function readConfig() {
     }
     return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
 }
-export const devCommand = new Command('dev')
-    .description('Start local development server with live sync')
-    .option('--no-logs', 'Disable automatic log tailing')
-    .option('--logs-only-file', 'Write logs to file only, not terminal')
-    .action(async (options) => {
+export async function execDev(options) {
     const config = readConfig();
     const creds = requireAuth();
     const client = new ApiClient(creds);
@@ -57,7 +57,7 @@ export const devCommand = new Command('dev')
         }
     }
     // Download fresh template to ensure latest version
-    console.log('Updating template...');
+    console.log(dim('Updating template...'));
     try {
         const zipData = await client.downloadSkeleton();
         extractZip(zipData, cwd);
@@ -74,65 +74,133 @@ export const devCommand = new Command('dev')
         }
     }
     catch {
-        console.warn('Template update failed. Continuing with current files.');
+        console.warn(yellow('Template update failed. Continuing with current files.'));
     }
     // Populate type definitions
     await populateTypes(cwd);
     // Start dev session first - this triggers DO onStart which may create remote commits
-    console.log('Starting dev session...');
+    console.log(dim('Starting dev session...'));
     const session = await client.startDevSession(config.appId);
-    console.log(`Preview: ${session.previewUrl}`);
     // Fetch SKILL.md (best-effort, after session so DO registries are available)
     await populateSkill(cwd, client, config.appId);
     // Sync AFTER starting session so we pick up any commits the DO created
-    console.log('Syncing with Runwork...');
+    console.log(dim('Syncing...'));
     const syncResult = syncWithRemote(cwd);
     switch (syncResult.status) {
         case 'skipped':
-            console.log('No commits yet. Skipping sync.');
+            console.log(dim('  No commits yet. Skipping sync.'));
             break;
         case 'synced':
-            console.log('Synced with Runwork.');
+            console.log(green('  Synced with Runwork.'));
             break;
         case 'merged':
-            console.log('Merged with Runwork (histories diverged).');
+            console.log(yellow('  Merged with Runwork (histories diverged).'));
             break;
         case 'sync-failed':
             if (syncResult.error === 'stash-conflict') {
                 console.error('Merge conflicts detected after stash pop. Resolve conflicts and restart.');
                 process.exit(1);
             }
-            console.warn('Pull failed (remote may not have commits yet). Continuing...');
+            console.warn(yellow(`Sync failed. Continuing...`));
+            if (syncResult.error) {
+                console.warn(dim(`  ${syncResult.error}`));
+            }
             break;
     }
     if (!syncResult.pushed && syncResult.status !== 'skipped' && syncResult.status !== 'sync-failed') {
-        console.warn('Push failed. Continuing with current state...');
+        console.warn(yellow('Push failed. Continuing with current state...'));
+    }
+    // Show banner
+    console.log(getDevBanner({ appName: config.appName, previewUrl: session.previewUrl, workspaceName: config.workspaceName }));
+    console.log(getKeyboardHints());
+    console.log('');
+    console.log(dim('  ─────────────────────────────────────────────'));
+    console.log('');
+    // Status line tracks sync activity
+    const statusLine = createStatusLine(process.stdout);
+    let syncedCount = 0;
+    let logFilter = 'all';
+    function updateStatus() {
+        const filterLabel = logFilter === 'all' ? 'All' : logFilter === 'events' ? 'Events' : 'Runtime';
+        const sep = '\x1b[90m\u2502\x1b[39m'; // dim │
+        statusLine.update(`${bold(config.appName)} ${sep} ${green(session.previewUrl)} ${sep} ${cyan(`${syncedCount} synced`)} ${sep} ${filterLabel} ${sep} \x1b[90mo\x1b[39m:open \x1b[90mi\x1b[39m:info \x1b[90ma/e/r\x1b[39m:filter \x1b[90mq\x1b[39m:quit`);
     }
+    updateStatus();
     // Declare logTailer before cleanup so cleanup can reference it
     let logTailer;
+    const keyboard = createKeyboardListener();
     // Register cleanup before starting watcher to avoid race
     const cleanup = async () => {
         console.log('\nStopping...');
         logTailer?.stop();
         await stopAutoCommit();
+        statusLine.destroy();
+        keyboard.stop(); // Last - stopping stdin can affect process exit
         process.exit(0);
     };
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
+    keyboard.start((action) => {
+        switch (action) {
+            case 'o':
+            case 'p':
+                import('open').then(m => m.default(session.previewUrl));
+                break;
+            case 'a':
+                logFilter = 'all';
+                console.log(dim('  Showing all logs.'));
+                updateStatus();
+                break;
+            case 'e':
+                logFilter = 'events';
+                console.log(dim('  Showing events only.'));
+                updateStatus();
+                break;
+            case 'r':
+                logFilter = 'runtime';
+                console.log(dim('  Showing runtime logs only.'));
+                updateStatus();
+                break;
+            case 'i':
+                console.log(getInfoPanel({
+                    appName: config.appName,
+                    previewUrl: session.previewUrl,
+                    workspaceName: config.workspaceName,
+                    directory: cwd,
+                }));
+                break;
+            case 'quit':
+                cleanup();
+                break;
+        }
+    });
     // Start file watcher
-    console.log('Watching for file changes...');
-    await watchAndAutoCommit(process.cwd(), client, config.appId);
+    await watchAndAutoCommit(process.cwd(), client, config.appId, {
+        onFastSync(count) {
+            syncedCount += count;
+            updateStatus();
+        },
+        onGitPush(count) {
+            syncedCount += count;
+            updateStatus();
+        },
+    });
     // Start log tailing (unless --no-logs)
-    if (options.logs !== false) {
+    if (options?.logs !== false) {
         logTailer = startLogTailer({
             appId: config.appId,
             client,
             projectDir: cwd,
-            toTerminal: !options.logsOnlyFile,
+            toTerminal: !options?.logsOnlyFile,
             toFile: true,
+            getFilter: () => logFilter,
         });
-        console.log('Log tailing active. Logs written to .runwork/logs.txt');
     }
     // Keep alive
     await new Promise(() => { });
-});
+}
+export const devCommand = new Command('dev')
+    .description('Start local development server with live sync')
+    .option('--no-logs', 'Disable automatic log tailing')
+    .option('--logs-only-file', 'Write logs to file only, not terminal')
+    .action(async (options) => execDev(options));

package/dist/commands/init.d.ts

@@ -1,2 +1,5 @@
 import { Command } from 'commander';
+import { ApiClient } from '../api/client.js';
+import type { WorkspaceInfo } from '../types.js';
+export declare function execInit(client: ApiClient, appName: string, workspace: WorkspaceInfo): Promise<string>;
 export declare const initCommand: Command;

package/dist/commands/init.js

@@ -1,32 +1,15 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
 import { writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { promptSelect, promptInput } from '../utils/prompt.js';
 import { generateManifest, saveManifest } from '../template/manifest.js';
 import { extractZip } from '../utils/zip.js';
 import { removeNestedGitDirs } from '../utils/fs.js';
-export const initCommand = new Command('init')
-    .description('Initialize a new Runwork app')
-    .argument('[name]', 'App name')
-    .action(async (name) => {
-    const creds = requireAuth();
-    const client = new ApiClient(creds);
-    const appName = name || await promptInput('App name');
-    if (!appName) {
-        console.error('App name is required.');
-        process.exit(1);
-    }
-    const workspaces = await client.listWorkspaces();
-    if (workspaces.length === 0) {
-        console.error('No workspaces found. Create one at runwork.ai first.');
-        process.exit(1);
-    }
-    const workspaceChoice = await promptSelect('Select workspace:', workspaces.map(w => ({ label: w.name, value: w })));
-    const workspace = workspaceChoice.value;
-    console.log(`Initializing "${appName}" in workspace "${workspace.name}"...`);
+import { runAgentWizard } from '../ui/banner.js';
+export async function execInit(client, appName, workspace) {
     const app = await client.initApp(workspace.id, appName);
     const slug = app.slug || appName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const dir = slug;
@@ -52,6 +35,7 @@ export const initCommand = new Command('init')
     // Write .runwork.json AFTER template extraction so it doesn't get overwritten
     const config = {
         workspaceId: workspace.id,
+        workspaceName: workspace.name,
         appId: app.id,
         appName: app.name,
     };
@@ -83,5 +67,29 @@ export const initCommand = new Command('init')
     execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: dir, stdio: 'inherit' });
     console.log(`\nApp "${app.name}" initialized in ${dir}/`);
     console.log(`Remote: ${remoteUrl}`);
-    console.log(`\nNext: cd ${dir} && runwork dev`);
+    return resolve(dir);
+}
+export const initCommand = new Command('init')
+    .description('Initialize a new Runwork app')
+    .argument('[name]', 'App name')
+    .action(async (name) => {
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    const appName = name || await promptInput('App name');
+    if (!appName) {
+        console.error('App name is required.');
+        process.exit(1);
+    }
+    const workspaces = await client.listWorkspaces();
+    if (workspaces.length === 0) {
+        console.error('No workspaces found. Create one at runwork.ai first.');
+        process.exit(1);
+    }
+    const workspaceChoice = await promptSelect('Select workspace:', workspaces.map(w => ({ label: w.name, value: w })));
+    const workspace = workspaceChoice.value;
+    console.log(`Initializing "${appName}" in workspace "${workspace.name}"...`);
+    const dir = await execInit(client, appName, workspace);
+    const slug = dir.split('/').pop() || dir;
+    await runAgentWizard(dir);
+    console.log(`Next: cd ${slug} && runwork dev`);
 });

package/dist/commands/login.js

@@ -1,32 +1,17 @@
 import { Command } from 'commander';
-import { ApiClient } from '../api/client.js';
-import { saveCredentials } from '../auth/store.js';
-import { configureGitCredentials } from '../git/credentials.js';
+import { performLogin } from '../auth/login-flow.js';
+import { bold, cyan } from '../ui/colors.js';
 export const loginCommand = new Command('login')
     .description('Authenticate with Runwork platform')
     .option('--base-url <url>', 'Platform URL', 'https://runwork.ai')
     .action(async (options) => {
-    const client = new ApiClient({ apiKey: '', email: '', baseUrl: options.baseUrl });
     console.log('Opening browser for authentication...');
-    const { sessionId, loginUrl } = await client.initiateLogin();
-    // Open browser
-    const open = await import('open');
-    await open.default(loginUrl);
-    console.log(`If browser didn't open, visit: ${loginUrl}`);
-    console.log('Waiting for authentication...');
-    // Poll for up to 5 minutes
-    const maxAttempts = 60;
-    const pollInterval = 5000;
-    for (let i = 0; i < maxAttempts; i++) {
-        await new Promise(resolve => setTimeout(resolve, pollInterval));
-        const result = await client.pollLogin(sessionId);
-        if (result) {
-            saveCredentials(result);
-            await configureGitCredentials(result.baseUrl || options.baseUrl);
-            console.log(`Logged in as ${result.email}`);
-            return;
-        }
-    }
-    console.error('Login timed out. Please try again.');
-    process.exit(1);
+    await performLogin(options.baseUrl);
+    console.log('');
+    console.log(bold('What next?'));
+    console.log('');
+    console.log(`  ${cyan('runwork init')}     Create a new app`);
+    console.log(`  ${cyan('runwork clone')}    Clone an existing app`);
+    console.log(`  ${cyan('runwork dev')}      Start developing (inside an app directory)`);
+    console.log('');
 });

package/dist/commands/open.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const openCommand: Command;

package/dist/commands/open.js

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { cyan } from '../ui/colors.js';
+export const openCommand = new Command('open')
+    .description('Open app preview or dashboard in browser')
+    .argument('[target]', 'What to open: preview (default), dashboard', 'preview')
+    .action(async (target) => {
+    if (!existsSync('.runwork.json')) {
+        console.error('No .runwork.json found. Run `runwork init` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(readFileSync('.runwork.json', 'utf-8'));
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    const open = await import('open');
+    switch (target) {
+        case 'preview': {
+            let previewUrl;
+            try {
+                const status = await client.getDevStatus(config.appId);
+                previewUrl = status.previewUrl;
+            }
+            catch {
+                const session = await client.startDevSession(config.appId);
+                previewUrl = session.previewUrl;
+            }
+            console.log(`Opening preview: ${cyan(previewUrl)}`);
+            await open.default(previewUrl);
+            break;
+        }
+        case 'dashboard': {
+            const url = `${creds.baseUrl}/apps/${config.appId}`;
+            console.log(`Opening dashboard: ${cyan(url)}`);
+            await open.default(url);
+            break;
+        }
+        default:
+            console.error(`Unknown target: ${target}. Use "preview" or "dashboard".`);
+            process.exit(1);
+    }
+});

package/dist/commands/welcome.d.ts

@@ -0,0 +1 @@
+export declare function runWelcomeWizard(): Promise<void>;

package/dist/commands/welcome.js

@@ -0,0 +1,83 @@
+import { getCredentials } from '../auth/store.js';
+import { performLogin } from '../auth/login-flow.js';
+import { ApiClient } from '../api/client.js';
+import { promptSelect, promptInput, promptConfirm } from '../utils/prompt.js';
+import { getWelcomeBanner, runAgentWizard } from '../ui/banner.js';
+import { cyan, dim, green } from '../ui/colors.js';
+export async function runWelcomeWizard() {
+    // Step 1: Welcome
+    console.log(getWelcomeBanner());
+    // Step 2: Login
+    let creds = getCredentials();
+    if (creds) {
+        console.log(green(`  Already logged in as ${creds.email}.`));
+    }
+    else {
+        console.log('Opening your browser to log in...');
+        console.log('');
+        creds = await performLogin();
+    }
+    // Step 3: Init or Clone
+    console.log('');
+    const action = await promptSelect('What would you like to do?', [
+        { label: 'Create a new app', value: 'init' },
+        { label: 'Clone an existing app', value: 'clone' },
+    ]);
+    const client = new ApiClient(creds);
+    let appDir;
+    if (action.value === 'init') {
+        const appName = await promptInput('App name');
+        if (!appName) {
+            console.error('App name is required.');
+            process.exit(1);
+        }
+        const workspaces = await client.listWorkspaces();
+        if (workspaces.length === 0) {
+            console.error('No workspaces found. Create one at runwork.ai first.');
+            process.exit(1);
+        }
+        let workspace;
+        if (workspaces.length === 1) {
+            workspace = workspaces[0];
+            console.log(dim(`  Using workspace: ${workspace.name}`));
+        }
+        else {
+            console.log('');
+            console.log('A workspace is where your apps live. Pick one:');
+            const choice = await promptSelect('Select workspace:', workspaces.map(w => ({ label: w.name, value: w })));
+            workspace = choice.value;
+        }
+        console.log('');
+        console.log(`Creating ${cyan(appName)} in workspace ${cyan(workspace.name)}...`);
+        const { execInit } = await import('./init.js');
+        appDir = await execInit(client, appName, workspace);
+    }
+    else {
+        const apps = await client.listApps();
+        if (apps.length === 0) {
+            console.error('No apps found. Choose "Create a new app" instead.');
+            process.exit(1);
+        }
+        const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
+        const { execClone } = await import('./clone.js');
+        appDir = await execClone(client, choice.value);
+    }
+    // Step 4: Agent guidance
+    await runAgentWizard(appDir);
+    // Step 5: Offer to start dev
+    console.log('');
+    const startDev = await promptConfirm('Start developing now?');
+    if (startDev) {
+        console.log('');
+        console.log(dim(`  Tip: Open another terminal and launch your AI agent in ${cyan(appDir)}`));
+        console.log('');
+        process.chdir(appDir);
+        const { execDev } = await import('./dev.js');
+        await execDev();
+    }
+    else {
+        const slug = appDir.split('/').pop() || appDir;
+        console.log('');
+        console.log(`Next: ${cyan(`cd ${slug} && runwork dev`)}`);
+    }
+}

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.5";
+export declare const VERSION = "0.3.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-types.ts -- do not edit
-export const VERSION = "0.2.5";
+export const VERSION = "0.3.0";

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

@@ -165,7 +165,7 @@ describe('syncWithRemote()', () => {
         expect(existsSync(join(local, 'local-file.txt'))).toBe(true);
         expect(existsSync(join(local, 'remote-only.txt'))).toBe(true);
     });
-    it('reports sync-failed when both rebase and merge have conflicts', () => {
+    it('auto-resolves conflicting unrelated histories by accepting remote', () => {
         const { local, remote } = createTestRepo();
         // Local modifies a file
         commitFile(local, 'shared.txt', 'local-line-1\nlocal-line-2\n', 'local init');
@@ -178,8 +178,10 @@ describe('syncWithRemote()', () => {
         execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
         execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
         const result = syncWithRemote(local);
-        // Both rebase and merge will fail on conflicting unrelated histories
-        expect(result.status).toBe('sync-failed');
+        // Conflicts auto-resolved with -X theirs (remote wins for first sync)
+        expect(result.status).toBe('merged');
+        // Remote version should win
+        expect(readFileSync(join(local, 'shared.txt'), 'utf-8')).toBe('remote-line-1\nremote-line-2\n');
     });
     it('stashes and restores dirty working tree during sync', () => {
         const { local, remote } = createTestRepo();
@@ -316,7 +318,7 @@ describe('syncWithRemote() edge cases', () => {
         // But local repo should be intact
         expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('hello');
     });
-    it('leaves repo clean (not in rebase/merge state) after sync-failed', () => {
+    it('leaves repo clean after auto-resolving conflicting unrelated histories', () => {
         const { local, remote } = createTestRepo();
         commitFile(local, 'shared.txt', 'local version\n', 'local init');
         // Create conflicting remote history
@@ -328,14 +330,14 @@ describe('syncWithRemote() edge cases', () => {
         execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
         execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
         const result = syncWithRemote(local);
-        expect(result.status).toBe('sync-failed');
+        // Auto-resolved with -X theirs
+        expect(result.status).toBe('merged');
         // Repo should NOT be in a rebase or merge state
         expect(existsSync(join(local, '.git', 'MERGE_HEAD'))).toBe(false);
         expect(existsSync(join(local, '.git', 'rebase-merge'))).toBe(false);
         expect(existsSync(join(local, '.git', 'rebase-apply'))).toBe(false);
-        // Working tree should be clean (original file intact)
-        const fileContent = readFileSync(join(local, 'shared.txt'), 'utf-8');
-        expect(fileContent).toBe('local version\n');
+        // Remote version wins
+        expect(readFileSync(join(local, 'shared.txt'), 'utf-8')).toBe('remote version\n');
     });
     it('handles merge conflict during rebase on related histories (same file edited both sides)', () => {
         const { local, remote } = createTestRepo();