runwork 0.14.0 → 0.15.1

package/dist/__tests__/install-scripts.test.js

@@ -165,6 +165,39 @@ describe('install.sh (end-to-end)', () => {
         const defaultBinary = join(workDir, '.runwork', 'bin', 'runwork');
         expect(existsSync(defaultBinary)).toBe(true);
     });
+    it('persists ~/.runwork/bin to a shell profile, idempotently, on a default install', async () => {
+        const linkDir = join(workDir, 'link');
+        const exportLine = 'export PATH="$HOME/.runwork/bin:$PATH"';
+        const marker = '# Added by Runwork CLI installer';
+        const profiles = ['.zshrc', '.bashrc', '.bash_profile', '.profile'].map((p) => join(workDir, p));
+        const read = (p) => (existsSync(p) ? readFileSync(p, 'utf-8') : '');
+        // First install with the default install dir ($HOME/.runwork/bin) triggers
+        // PATH persistence.
+        const r1 = await runInstallSh(envFor({ RUNWORK_BIN_LINK_DIR: linkDir }));
+        expect(r1.status, `installer failed:\n${r1.stdout}\n${r1.stderr}`).toBe(0);
+        const written = profiles.filter((p) => read(p).includes(exportLine));
+        expect(written.length, 'expected the export line in at least one profile').toBeGreaterThan(0);
+        expect(profiles.some((p) => read(p).includes(marker))).toBe(true);
+        // Re-running must NOT append a second time (guarded on .runwork/bin).
+        const r2 = await runInstallSh(envFor({ RUNWORK_BIN_LINK_DIR: linkDir }));
+        expect(r2.status).toBe(0);
+        for (const p of written) {
+            const occurrences = read(p).split('.runwork/bin').length - 1;
+            expect(occurrences, `profile ${p} should reference .runwork/bin exactly once`).toBe(1);
+        }
+    });
+    it('does NOT touch shell profiles when a custom RUNWORK_INSTALL_DIR is used', async () => {
+        const result = await runInstallSh(envFor({
+            RUNWORK_INSTALL_DIR: join(workDir, 'install'),
+            RUNWORK_BIN_LINK_DIR: join(workDir, 'link'),
+        }));
+        expect(result.status).toBe(0);
+        const profiles = ['.zshrc', '.bashrc', '.bash_profile', '.profile'].map((p) => join(workDir, p));
+        for (const p of profiles) {
+            if (existsSync(p))
+                expect(readFileSync(p, 'utf-8')).not.toContain('.runwork/bin');
+        }
+    });
     it('aborts on sha256 mismatch and leaves the install directory untouched', async () => {
         // Tamper with the archive the server is about to serve.
         writeFileSync(archivePath, Buffer.from('tampered payload'));

package/dist/agents/__tests__/chatgpt-registry.test.d.ts

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

package/dist/agents/__tests__/chatgpt-registry.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { getAgent, getAgentFamily, getFamilyAgents, isConnectOnlyAgent, isWebAgent, } from '../registry-data.js';
+describe('ChatGPT registry entries', () => {
+    it('registers both Web and Desktop entries', () => {
+        const web = getAgent('chatgpt');
+        const app = getAgent('chatgpt-app');
+        expect(web).toBeDefined();
+        expect(app).toBeDefined();
+        expect(web?.category).toBe('web');
+        expect(app?.category).toBe('desktop');
+        expect(web?.firstClass).toBe(true);
+        expect(app?.firstClass).toBe(true);
+    });
+    it('treats Web entry as always-available with a URL launch', () => {
+        const web = getAgent('chatgpt');
+        expect(web?.detection).toEqual({ method: 'always' });
+        expect(web?.launch?.url).toContain('chatgpt.com');
+        expect(isWebAgent('chatgpt')).toBe(true);
+        expect(isWebAgent('chatgpt-app')).toBe(false);
+    });
+    it('marks both entries connect-only (no local config paths)', () => {
+        for (const slug of ['chatgpt', 'chatgpt-app']) {
+            const agent = getAgent(slug);
+            expect(isConnectOnlyAgent(agent)).toBe(true);
+            expect(agent?.skillsPaths).toBeUndefined();
+            expect(agent?.mcpConfigPath).toBeUndefined();
+            expect(agent?.instructionFile).toBeUndefined();
+        }
+    });
+    it('does not mark file-backed agents as connect-only', () => {
+        expect(isConnectOnlyAgent(getAgent('claude-code'))).toBe(false);
+        expect(isConnectOnlyAgent(getAgent('codex'))).toBe(false);
+    });
+    it('groups both entries under one family', () => {
+        expect(getAgentFamily('chatgpt')).toBe('chatgpt');
+        expect(getAgentFamily('chatgpt-app')).toBe('chatgpt');
+        const family = getFamilyAgents('chatgpt').map((a) => a.slug).sort();
+        expect(family).toEqual(['chatgpt', 'chatgpt-app']);
+    });
+    it('falls back to the slug as family for standalone agents', () => {
+        expect(getAgentFamily('claude-code')).toBe('claude-code');
+        expect(getFamilyAgents('claude-code').map((a) => a.slug)).toEqual(['claude-code']);
+    });
+    it('provides team/personal manual-setup variants and a copyable MCP URL', () => {
+        for (const slug of ['chatgpt', 'chatgpt-app']) {
+            const setup = getAgent(slug)?.manualSetup;
+            expect(setup?.showAfter).toBe('connecting');
+            expect(setup?.copyValue?.token).toBe('{mcpUrl}');
+            const keys = setup?.variants?.map((v) => v.key).sort();
+            expect(keys).toEqual(['personal', 'team']);
+            // Every variant carries at least one step.
+            for (const variant of setup?.variants ?? []) {
+                expect(variant.steps.length).toBeGreaterThan(0);
+            }
+        }
+    });
+    it('uses url-prompt resume for connect-only ChatGPT entries', () => {
+        expect(getAgent('chatgpt')?.resumeCapability?.mode).toBe('url-prompt');
+        expect(getAgent('chatgpt-app')?.resumeCapability?.mode).toBe('url-prompt');
+    });
+});

package/dist/agents/__tests__/claude-code-managed-block.test.js

@@ -1,8 +1,9 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
 import { ClaudeCodeAdapter } from '../claude-code.js';
+const MARKER = '# runwork-managed';
 let homeDir;
 let originalHome;
 beforeEach(() => {
@@ -10,7 +11,6 @@ beforeEach(() => {
     homeDir = join(tmpdir(), `runwork-cc-managed-${Date.now()}-${Math.random().toString(36).slice(2)}`);
     mkdirSync(join(homeDir, '.claude'), { recursive: true });
     process.env.HOME = homeDir;
-    // Reset the homedir() cache by mocking it via env (Node's os.homedir reads HOME on macOS/Linux).
 });
 afterEach(() => {
     if (originalHome)
@@ -23,75 +23,83 @@ afterEach(() => {
     catch { /* ignore */ }
     vi.restoreAllMocks();
 });
+function settingsPath() {
+    return join(homeDir, '.claude', 'settings.json');
+}
 function writeSettings(settings) {
-    writeFileSync(join(homeDir, '.claude', 'settings.json'), JSON.stringify(settings, null, 2));
+    writeFileSync(settingsPath(), JSON.stringify(settings, null, 2));
+}
+function readSettings() {
+    return JSON.parse(readFileSync(settingsPath(), 'utf-8'));
 }
-describe('ClaudeCodeAdapter.readManagedBlock (user scope)', () => {
+describe('ClaudeCodeAdapter.readManagedBlock (markerless)', () => {
     it('returns undefined when settings.json is missing', async () => {
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result).toBeUndefined();
+        expect(await adapter.readManagedBlock('user')).toBeUndefined();
     });
-    it('returns empty arrays when permissions key is absent', async () => {
-        writeSettings({ model: 'claude-sonnet-4-6' });
+    it('returns undefined even when a legacy marker is present (no on-disk read)', async () => {
+        writeSettings({ permissions: { allow: [MARKER, 'Bash(runwork *)'], deny: [] } });
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result).toEqual({ allow: [], deny: [] });
+        expect(await adapter.readManagedBlock('user')).toBeUndefined();
     });
-    it('returns empty arrays when marker is absent', async () => {
-        writeSettings({ permissions: { allow: ['Bash(npm test)'], deny: ['Bash(rm)'] } });
-        const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result).toEqual({ allow: [], deny: [] });
-    });
-    it('returns entries after marker in allow', async () => {
+});
+describe('ClaudeCodeAdapter.writeAgentConfig legacy-marker migration', () => {
+    it('strips the legacy marker from allow and deny when injecting new rules', async () => {
         writeSettings({
             permissions: {
-                allow: ['Bash(npm test)', '# runwork-managed', 'Bash(runwork *)', 'Bash(git status)'],
-                deny: [],
+                allow: [MARKER, 'Bash(runwork *)', 'Bash(git status)'],
+                deny: [MARKER, 'Bash(rm -rf *)'],
             },
         });
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result?.allow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
-        expect(result?.deny).toEqual([]);
+        await adapter.writeAgentConfig({ permissionRules: { allow: ['Bash(runwork *)', 'Bash(git status)'], deny: ['Bash(rm -rf *)'] } }, 'user', { allow: ['Bash(runwork *)', 'Bash(git status)'], deny: ['Bash(rm -rf *)'] });
+        const perms = readSettings().permissions;
+        expect(perms.allow).not.toContain(MARKER);
+        expect(perms.deny).not.toContain(MARKER);
+        expect(perms.allow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
+        expect(perms.deny).toEqual(['Bash(rm -rf *)']);
     });
-    it('returns entries after marker in deny', async () => {
+    it('strips the legacy marker even when there are no new permission rules', async () => {
         writeSettings({
             permissions: {
-                allow: [],
-                deny: ['Bash(curl evil.com)', '# runwork-managed', 'Bash(rm -rf *)'],
+                allow: ['Bash(user-custom)', MARKER, 'Bash(runwork *)'],
+                deny: [MARKER],
             },
         });
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result?.deny).toEqual(['Bash(rm -rf *)']);
+        await adapter.writeAgentConfig({}, 'user');
+        const perms = readSettings().permissions;
+        expect(perms.allow).toEqual(['Bash(user-custom)', 'Bash(runwork *)']);
+        expect(perms.deny).toEqual([]);
     });
-    it('returns empty when marker exists but nothing follows', async () => {
+});
+describe('ClaudeCodeAdapter.writeAgentConfig markerless merge', () => {
+    it('preserves user entries and subtracts the baseline before re-injecting', async () => {
         writeSettings({
             permissions: {
-                allow: ['Bash(npm test)', '# runwork-managed'],
-                deny: [],
+                allow: ['Bash(user-custom)', 'Bash(runwork *)', 'Bash(old-default)'],
             },
         });
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result?.allow).toEqual([]);
+        await adapter.writeAgentConfig({ permissionRules: { allow: ['Bash(runwork *)', 'Bash(git status)'] } }, 'user', { allow: ['Bash(runwork *)', 'Bash(old-default)'] });
+        // user entry kept; baseline-only entry (old-default) dropped; new managed set appended
+        expect(readSettings().permissions.allow).toEqual([
+            'Bash(user-custom)',
+            'Bash(runwork *)',
+            'Bash(git status)',
+        ]);
     });
-    it('returns undefined on JSON parse error', async () => {
-        writeFileSync(join(homeDir, '.claude', 'settings.json'), '{ not valid json');
+    it('writes model preference and defaultMode', async () => {
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result).toBeUndefined();
+        await adapter.writeAgentConfig({ modelPreference: 'claude-sonnet-4-6', permissionRules: { allow: ['Bash(runwork *)'], defaultMode: 'acceptEdits' } }, 'user');
+        const settings = readSettings();
+        expect(settings.model).toBe('claude-sonnet-4-6');
+        expect(settings.permissions.defaultMode).toBe('acceptEdits');
+        expect(settings.permissions.allow).toEqual(['Bash(runwork *)']);
     });
-    it('filters out non-string entries after marker (defensive)', async () => {
-        writeSettings({
-            permissions: {
-                allow: ['# runwork-managed', 'Bash(runwork *)', 42, null, 'Bash(git status)'],
-            },
-        });
+    it('does not create an empty settings file when there is nothing to write', async () => {
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result?.allow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
+        await adapter.writeAgentConfig({}, 'user');
+        expect(existsSync(settingsPath())).toBe(false);
     });
 });

package/dist/agents/__tests__/detection.test.js

@@ -83,4 +83,7 @@ describe('runAgentDetection', () => {
             ],
         })).toBe(false);
     });
+    it('always method reports true without any local probe (web-only agents)', async () => {
+        expect(await runAgentDetection({ method: 'always' })).toBe(true);
+    });
 });

package/dist/agents/claude-code.d.ts

@@ -31,11 +31,17 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     writeBuiltInHooks(scope: 'project' | 'user'): Promise<void>;
     writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
     writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
-    /** Remove the managed marker and all entries after it from a permissions array */
-    private removeAfterMarker;
-    /** Return entries after the managed marker for both allow and deny lists. */
-    readManagedBlock(scope: 'project' | 'user'): Promise<{
+    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user', baseline?: {
+        allow?: string[];
+        deny?: string[];
+    }): Promise<void>;
+    /**
+     * Markerless adapter: removal detection relies on the `baseline`
+     * (state.lastInjected) passed to writeAgentConfig, exactly like Cursor, since
+     * the adapter no longer writes an on-disk sentinel to delimit its entries.
+     * Returning undefined tells the sync loop to skip on-disk removal detection.
+     */
+    readManagedBlock(_scope: 'project' | 'user'): Promise<{
         allow?: string[];
         deny?: string[];
     } | undefined>;

package/dist/agents/claude-code.js

@@ -7,8 +7,17 @@ import { buildSkillMd } from './types.js';
 import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig, removeRunworkMcpServers } from './utils/json-config.js';
 import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile } from './utils/instruction-hint.js';
 import { SESSION_START_HOOK_SCRIPT } from './session-start-hook.js';
+import { mergeMarkerless } from './defaults-merge.js';
 const PLUGIN_NAME = 'runwork';
 const PLUGIN_VERSION = '1.0.0';
+/**
+ * Legacy in-array sentinel that older CLI versions injected at the head of the
+ * managed permission block. Claude Code >= 2.1.x validates every allow/deny
+ * entry as a tool rule and rejects this with "matches no known tool" on
+ * startup, so the adapter is now markerless and actively strips this marker
+ * from any existing user's settings on their next sync.
+ */
+const LEGACY_MANAGED_MARKER = '# runwork-managed';
 function getPluginJson() {
     return {
         name: PLUGIN_NAME,
@@ -215,18 +224,31 @@ export class ClaudeCodeAdapter {
         }
     }
     // ── Agent config (model, permissions) ──────────────────────────────
-    async writeAgentConfig(config, scope) {
+    async writeAgentConfig(config, scope, baseline) {
         const settingsPath = scope === 'project'
             ? join(process.cwd(), '.claude', 'settings.json')
             : join(homedir(), '.claude', 'settings.json');
+        const hadFile = existsSync(settingsPath);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let settings = {};
-        if (existsSync(settingsPath)) {
+        if (hadFile) {
             try {
                 settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
             }
             catch { /* start fresh */ }
         }
+        // Retro-fix migration: strip the legacy in-array sentinel from any existing
+        // settings, regardless of whether we inject new rules this sync. This is
+        // what removes the broken "# runwork-managed" entry that makes Claude Code
+        // >= 2.1.x print "matches no known tool" on startup.
+        if (settings.permissions && typeof settings.permissions === 'object') {
+            for (const key of ['allow', 'deny']) {
+                const arr = settings.permissions[key];
+                if (Array.isArray(arr)) {
+                    settings.permissions[key] = arr.filter((x) => x !== LEGACY_MANAGED_MARKER);
+                }
+            }
+        }
         if (config.modelPreference) {
             settings.model = config.modelPreference;
         }
@@ -234,55 +256,32 @@ export class ClaudeCodeAdapter {
             if (!settings.permissions)
                 settings.permissions = {};
             const perms = settings.permissions;
-            const MANAGED_MARKER = '# runwork-managed';
+            // Markerless merge: subtract our previous contribution (baseline) to leave
+            // the user's own entries intact, then append the freshly resolved set.
             if (config.permissionRules.allow) {
-                const cleanExisting = this.removeAfterMarker(perms.allow ?? [], MANAGED_MARKER);
-                perms.allow = [...cleanExisting, MANAGED_MARKER, ...config.permissionRules.allow];
+                perms.allow = mergeMarkerless(Array.isArray(perms.allow) ? perms.allow : [], baseline?.allow ?? [], config.permissionRules.allow);
             }
             if (config.permissionRules.deny) {
-                const cleanExisting = this.removeAfterMarker(perms.deny ?? [], MANAGED_MARKER);
-                perms.deny = [...cleanExisting, MANAGED_MARKER, ...config.permissionRules.deny];
+                perms.deny = mergeMarkerless(Array.isArray(perms.deny) ? perms.deny : [], baseline?.deny ?? [], config.permissionRules.deny);
             }
             if (config.permissionRules.defaultMode) {
                 perms.defaultMode = config.permissionRules.defaultMode;
             }
         }
+        // Nothing to persist and no file to clean up: avoid creating an empty file.
+        if (!hadFile && !config.modelPreference && !config.permissionRules)
+            return;
         mkdirSync(join(settingsPath, '..'), { recursive: true });
         writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
     }
-    /** Remove the managed marker and all entries after it from a permissions array */
-    removeAfterMarker(arr, marker) {
-        const idx = arr.indexOf(marker);
-        return idx >= 0 ? arr.slice(0, idx) : [...arr];
-    }
-    /** Return entries after the managed marker for both allow and deny lists. */
-    async readManagedBlock(scope) {
-        const settingsPath = scope === 'project'
-            ? join(process.cwd(), '.claude', 'settings.json')
-            : join(homedir(), '.claude', 'settings.json');
-        if (!existsSync(settingsPath))
-            return undefined;
-        const MANAGED_MARKER = '# runwork-managed';
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-            const perms = settings?.permissions;
-            if (!perms || typeof perms !== 'object')
-                return { allow: [], deny: [] };
-            const extractAfter = (arr) => {
-                if (!Array.isArray(arr))
-                    return [];
-                const idx = arr.indexOf(MANAGED_MARKER);
-                return idx >= 0 ? arr.slice(idx + 1).filter((x) => typeof x === 'string') : [];
-            };
-            return {
-                allow: extractAfter(perms.allow),
-                deny: extractAfter(perms.deny),
-            };
-        }
-        catch {
-            return undefined;
-        }
+    /**
+     * Markerless adapter: removal detection relies on the `baseline`
+     * (state.lastInjected) passed to writeAgentConfig, exactly like Cursor, since
+     * the adapter no longer writes an on-disk sentinel to delimit its entries.
+     * Returning undefined tells the sync loop to skip on-disk removal detection.
+     */
+    async readManagedBlock(_scope) {
+        return undefined;
     }
     // ── Cleanup (uninstall) ────────────────────────────────────────────
     async cleanup(scope, manifest) {
@@ -320,18 +319,18 @@ export class ClaudeCodeAdapter {
             if (existsSync(settingsPath)) {
                 try {
                     const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-                    // Remove managed permission entries
+                    // Remove managed permission entries. Legacy installs carry the
+                    // in-array marker, so everything from the marker onward is ours.
+                    // Always also drop any stray marker so uninstall never leaves the
+                    // entry that breaks Claude Code startup.
                     if (settings.permissions) {
-                        const MANAGED_MARKER = '# runwork-managed';
-                        if (settings.permissions.allow) {
-                            const idx = settings.permissions.allow.indexOf(MANAGED_MARKER);
-                            if (idx >= 0)
-                                settings.permissions.allow = settings.permissions.allow.slice(0, idx);
-                        }
-                        if (settings.permissions.deny) {
-                            const idx = settings.permissions.deny.indexOf(MANAGED_MARKER);
-                            if (idx >= 0)
-                                settings.permissions.deny = settings.permissions.deny.slice(0, idx);
+                        for (const key of ['allow', 'deny']) {
+                            const arr = settings.permissions[key];
+                            if (!Array.isArray(arr))
+                                continue;
+                            const idx = arr.indexOf(LEGACY_MANAGED_MARKER);
+                            settings.permissions[key] = (idx >= 0 ? arr.slice(0, idx) : arr)
+                                .filter((x) => x !== LEGACY_MANAGED_MARKER);
                         }
                     }
                     // Remove plugin enablement

package/dist/agents/cursor.d.ts

@@ -1,19 +1,6 @@
 import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile } from './types.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 declare function mergeMarkerless(existing: string[], baseline: string[], incoming: string[]): string[];
+import { mergeMarkerless } from './defaults-merge.js';
+export { mergeMarkerless };
 export declare class CursorAdapter implements AgentAdapter {
     name: string;
     slug: string;

package/dist/agents/cursor.js

@@ -5,39 +5,9 @@ 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;
-}
+import { mergeMarkerless } from './defaults-merge.js';
+// Re-exported for backward compatibility with existing importers/tests.
+export { mergeMarkerless };
 export class CursorAdapter {
     name = 'Cursor';
     slug = 'cursor';

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

@@ -20,6 +20,21 @@ export declare function computeApplicable(baked: string[], optOuts: string[]): s
  */
 export declare function mergeAllow(applicableDefaults: string[], teamRules: string[]): string[];
 export declare function unique(items: string[]): string[];
+/**
+ * Merge a new managed list into a markerless on-disk array while preserving
+ * user-added entries. Shared by all markerless adapters (Cursor, Claude Code).
+ *
+ * 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 declare function mergeMarkerless(existing: string[], baseline: string[], incoming: 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 {

package/dist/agents/defaults-merge.js

@@ -45,6 +45,25 @@ export function unique(items) {
     }
     return out;
 }
+/**
+ * Merge a new managed list into a markerless on-disk array while preserving
+ * user-added entries. Shared by all markerless adapters (Cursor, Claude Code).
+ *
+ * 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));
+    return unique([...userEntries, ...incoming]);
+}
 /** True if no per-agent state has ever been recorded — first sync after upgrade or fresh install. */
 export function isBootstrap(state) {
     return state === undefined;

package/dist/agents/detection.js

@@ -85,6 +85,9 @@ export async function runAgentDetection(detection) {
             const probes = await Promise.all(detection.target.map((p) => runAgentDetection(p)));
             return probes.some(Boolean);
         }
+        case 'always':
+            // Web-only agents have no local footprint; always treated as available.
+            return true;
         default:
             return false;
     }

package/dist/agents/intro-skill.js

@@ -300,14 +300,14 @@ export function generateIntroSkill(ctx) {
     lines.push('| `runwork info --json` | Full workspace and app context |');
     lines.push('| `runwork init my-app` | Create a new app |');
     lines.push('| `runwork dev` | Start local development (watches files, syncs automatically) |');
-    lines.push('| `runwork deploy` | Deploy to production |');
+    lines.push('| `runwork deploy` | Deploy to production (`--detach` runs in the background to survive shell timeouts; `runwork deploy --status` polls the result) |');
     lines.push('| `runwork entities list` | Browse data across apps |');
     lines.push('| `runwork entities records <name>` | Query entity records |');
     lines.push('| `runwork workflows trigger <name>` | Trigger a workflow |');
     lines.push('| `runwork integrations call <id> <method> <path>` | Call an integration API |');
     lines.push('| `runwork integrations search <query>` | Search 3,200+ available integrations |');
     lines.push('| `runwork logs` | View app logs |');
-    lines.push('| `runwork doctor` | Check system health |');
+    lines.push('| `runwork doctor` | Check system health (`--fix` auto-remediates git auth/remote; `--check <names>` scopes output) |');
     lines.push('| `runwork setup` | Set up workspace connection and sync to agents |');
     lines.push('| `runwork sync` | Sync skills, MCP servers, and settings to local agents |');
     lines.push('');
@@ -323,6 +323,8 @@ export function generateIntroSkill(ctx) {
     lines.push('');
     lines.push('> By default, `runwork init` scaffolds into `~/.runwork/apps/<slug>` so every app has a predictable home. Pass `--here` to scaffold in the current directory instead.');
     lines.push('');
+    lines.push('> Clone/init into a normal working directory (e.g. under your home folder). Some sandboxed "outputs" mounts disallow the unlink operations git uses for pack files, which can corrupt the repo ("unable to unlink \'.git/objects/pack/...\': Operation not permitted"). If you hit that, switch to a standard path.');
+    lines.push('');
     lines.push('**CLI development workflow:**');
     lines.push('1. `runwork init my-app` -- scaffold the app (created at `~/.runwork/apps/my-app`)');
     lines.push('2. `cd ~/.runwork/apps/my-app` -- enter the app directory');
@@ -385,7 +387,7 @@ export function generateIntroSkill(ctx) {
     lines.push('- **Connect workspace:** `runwork login` then `runwork setup`');
     lines.push('- **Connect an integration:** Visit the workspace settings in the web dashboard at https://runwork.ai, or use `runwork integrations search <query>` to find services');
     lines.push('- **Web dashboard:** https://runwork.ai for visual management of everything');
-    lines.push('- **Troubleshoot:** `runwork doctor` checks system health; `runwork logs` shows app output');
+    lines.push('- **Troubleshoot:** `runwork doctor` checks system health (`runwork doctor --fix` auto-repairs git auth and the runwork remote); `runwork logs` shows app output');
     lines.push('');
     // References
     lines.push('### References');