runwork 0.15.0 → 0.15.2

package/dist/agents/__tests__/defaults-merge.test.js

@@ -1,268 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { detectRemovals, computeApplicable, mergeAllow, isBootstrap, resolveAgentDefaults, unique, } from '../defaults-merge.js';
-describe('detectRemovals', () => {
-    it('returns lastInjected items missing from onDisk', () => {
-        expect(detectRemovals(['a', 'b', 'c'], ['a', 'c'])).toEqual(['b']);
-    });
-    it('returns empty when nothing was removed', () => {
-        expect(detectRemovals(['a', 'b'], ['a', 'b', 'c'])).toEqual([]);
-    });
-    it('returns all when onDisk is empty', () => {
-        expect(detectRemovals(['a', 'b'], [])).toEqual(['a', 'b']);
-    });
-    it('returns empty when lastInjected is empty', () => {
-        expect(detectRemovals([], ['a', 'b'])).toEqual([]);
-    });
-});
-describe('computeApplicable', () => {
-    it('filters out opted-out items', () => {
-        expect(computeApplicable(['a', 'b', 'c'], ['b'])).toEqual(['a', 'c']);
-    });
-    it('returns full set when no opt-outs', () => {
-        expect(computeApplicable(['a', 'b'], [])).toEqual(['a', 'b']);
-    });
-    it('returns empty when everything is opted out', () => {
-        expect(computeApplicable(['a', 'b'], ['a', 'b'])).toEqual([]);
-    });
-});
-describe('mergeAllow', () => {
-    it('places defaults before team rules', () => {
-        expect(mergeAllow(['default1', 'default2'], ['team1'])).toEqual([
-            'default1',
-            'default2',
-            'team1',
-        ]);
-    });
-    it('dedupes silently when team rule equals default', () => {
-        expect(mergeAllow(['Bash(runwork *)', 'Bash(git status)'], ['Bash(runwork *)'])).toEqual([
-            'Bash(git status)',
-            'Bash(runwork *)',
-        ]);
-    });
-    it('preserves order within each segment', () => {
-        expect(mergeAllow(['a', 'b', 'c'], ['x', 'y'])).toEqual(['a', 'b', 'c', 'x', 'y']);
-    });
-    it('handles empty team rules', () => {
-        expect(mergeAllow(['a', 'b'], [])).toEqual(['a', 'b']);
-    });
-    it('handles empty defaults', () => {
-        expect(mergeAllow([], ['x', 'y'])).toEqual(['x', 'y']);
-    });
-});
-describe('unique', () => {
-    it('removes duplicates preserving first-seen order', () => {
-        expect(unique(['a', 'b', 'a', 'c', 'b'])).toEqual(['a', 'b', 'c']);
-    });
-});
-describe('isBootstrap', () => {
-    it('true when state is undefined', () => {
-        expect(isBootstrap(undefined)).toBe(true);
-    });
-    it('false when state is defined (even if empty)', () => {
-        const state = {
-            lastInjected: {},
-            userOptOuts: {},
-        };
-        expect(isBootstrap(state)).toBe(false);
-    });
-});
-describe('resolveAgentDefaults', () => {
-    const baked = {
-        allow: ['Bash(runwork *)', 'Bash(git status)', 'Bash(ls:*)'],
-        deny: ['Bash(rm -rf *)'],
-    };
-    it('case 1: no baked defaults emits team rules unchanged', () => {
-        const result = resolveAgentDefaults({
-            baked: undefined,
-            state: undefined,
-            onDisk: undefined,
-            team: { allow: ['custom'], deny: [] },
-        });
-        expect(result.managedAllow).toEqual(['custom']);
-        expect(result.managedDeny).toEqual([]);
-        expect(result.applicableAllow).toEqual([]);
-        expect(result.bootstrapped).toBe(false);
-    });
-    it('case 2: bootstrap does NOT inject defaults but applies team rules', () => {
-        const result = resolveAgentDefaults({
-            baked,
-            state: undefined,
-            onDisk: { allow: ['userPersonalRule'] },
-            team: { allow: ['teamRule'] },
-        });
-        expect(result.managedAllow).toEqual(['teamRule']);
-        expect(result.applicableAllow).toEqual([]);
-        expect(result.bootstrapped).toBe(true);
-        expect(result.newOptOutsAllow).toEqual([]);
-    });
-    it('case 3 normal: injects baked defaults when state has empty injection', () => {
-        const state = {
-            lastInjected: { allow: [], deny: [] },
-            userOptOuts: { allow: [], deny: [] },
-        };
-        const result = resolveAgentDefaults({
-            baked,
-            state,
-            onDisk: { allow: [], deny: [] },
-            team: undefined,
-        });
-        expect(result.managedAllow).toEqual(baked.allow);
-        expect(result.managedDeny).toEqual(baked.deny);
-        expect(result.applicableAllow).toEqual(baked.allow);
-        expect(result.bootstrapped).toBe(false);
-    });
-    it('case 3 normal: sticky opt-out — removed entry stays out next sync', () => {
-        // Previous sync injected the 3 defaults. User removed 'Bash(ls:*)' from
-        // settings.json. On the next sync we should detect that and never
-        // re-inject it.
-        const state = {
-            lastInjected: { allow: baked.allow, deny: baked.deny },
-            userOptOuts: { allow: [], deny: [] },
-        };
-        const result = resolveAgentDefaults({
-            baked,
-            state,
-            onDisk: { allow: ['Bash(runwork *)', 'Bash(git status)'], deny: baked.deny },
-            team: undefined,
-        });
-        expect(result.newOptOutsAllow).toEqual(['Bash(ls:*)']);
-        expect(result.applicableAllow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
-        expect(result.managedAllow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
-        expect(result.removalsThisSync.allow).toBe(1);
-    });
-    it('case 3 normal: opt-out persists even when on-disk equals lastInjected', () => {
-        // User opted out 'Bash(ls:*)' two syncs ago. Sync after that ran with
-        // applicable = [runwork *, git status]. Now another sync: on-disk has
-        // exactly that. We should NOT re-inject 'Bash(ls:*)'.
-        const state = {
-            lastInjected: { allow: ['Bash(runwork *)', 'Bash(git status)'] },
-            userOptOuts: { allow: ['Bash(ls:*)'] },
-        };
-        const result = resolveAgentDefaults({
-            baked,
-            state,
-            onDisk: { allow: ['Bash(runwork *)', 'Bash(git status)'] },
-            team: undefined,
-        });
-        expect(result.applicableAllow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
-        expect(result.newOptOutsAllow).toEqual(['Bash(ls:*)']);
-        expect(result.removalsThisSync.allow).toBe(0);
-    });
-    it('case 3 normal: baked-default shrink auto-removes from managed block', () => {
-        // CLI used to inject ['a','b','c']. New CLI version only has ['a','b'].
-        // Previous sync recorded ['a','b','c'] as lastInjected. User did not
-        // touch settings.json — onDisk still has ['a','b','c']. Next sync:
-        // 'c' is no longer in baked → applicable = ['a','b'] → managed = ['a','b'].
-        // No opt-out should be created for 'c' (it was a baked-default removal,
-        // not a user removal).
-        const oldBaked = {
-            allow: ['a', 'b', 'c'],
-            deny: [],
-        };
-        const newBaked = {
-            allow: ['a', 'b'],
-            deny: [],
-        };
-        const state = {
-            lastInjected: { allow: oldBaked.allow },
-            userOptOuts: { allow: [] },
-        };
-        const result = resolveAgentDefaults({
-            baked: newBaked,
-            state,
-            onDisk: { allow: ['a', 'b', 'c'] },
-            team: undefined,
-        });
-        expect(result.applicableAllow).toEqual(['a', 'b']);
-        expect(result.managedAllow).toEqual(['a', 'b']);
-        // 'c' was on-disk so detectRemovals doesn't flag it; opt-outs stay empty.
-        expect(result.newOptOutsAllow).toEqual([]);
-    });
-    it('case 3 normal: team rules dedupe silently with defaults', () => {
-        const state = {
-            lastInjected: { allow: [] },
-            userOptOuts: { allow: [] },
-        };
-        const result = resolveAgentDefaults({
-            baked: { allow: ['Bash(runwork *)', 'Bash(ls:*)'], deny: [] },
-            state,
-            onDisk: { allow: [] },
-            team: { allow: ['Bash(runwork *)', 'Bash(npm test)'] },
-        });
-        // Default 'Bash(runwork *)' overlaps with team; team copy wins on position.
-        expect(result.managedAllow).toEqual([
-            'Bash(ls:*)',
-            'Bash(runwork *)',
-            'Bash(npm test)',
-        ]);
-    });
-    it('case 3 normal: simultaneous removal + new baked addition', () => {
-        // Previous sync injected ['a','b']. User removed 'a'. CLI added 'c'.
-        // Result: applicable = ['b','c'] (a opted out, c is new).
-        const state = {
-            lastInjected: { allow: ['a', 'b'] },
-            userOptOuts: { allow: [] },
-        };
-        const result = resolveAgentDefaults({
-            baked: { allow: ['a', 'b', 'c'], deny: [] },
-            state,
-            onDisk: { allow: ['b'] },
-            team: undefined,
-        });
-        expect(result.newOptOutsAllow).toEqual(['a']);
-        expect(result.applicableAllow).toEqual(['b', 'c']);
-    });
-    it('case 3 markerless: undefined onDisk does NOT fabricate opt-outs (Cursor)', () => {
-        // Cursor's readManagedBlock returns undefined because there's no marker
-        // on disk to identify our entries. The resolver must NOT treat that as
-        // "everything was removed" — otherwise every default becomes a sticky
-        // opt-out after the first injection, corrupting setup.json forever.
-        const state = {
-            lastInjected: { allow: ['runwork', 'git status', 'ls'] },
-            userOptOuts: { allow: [] },
-        };
-        const result = resolveAgentDefaults({
-            baked,
-            state,
-            onDisk: undefined,
-            team: undefined,
-        });
-        // No new opt-outs created from the missing read.
-        expect(result.newOptOutsAllow).toEqual([]);
-        expect(result.removalsThisSync.allow).toBe(0);
-        // Defaults are still applied (filtered by any existing opt-outs).
-        expect(result.applicableAllow).toEqual(baked.allow);
-    });
-    it('case 3 markerless: existing opt-outs are preserved when onDisk is undefined', () => {
-        // User had previously opted out of 'Bash(ls:*)' (recorded in state).
-        // This sync's onDisk read came back undefined. We must keep the existing
-        // opt-out, not silently re-inject the default.
-        const state = {
-            lastInjected: { allow: ['Bash(runwork *)', 'Bash(git status)'] },
-            userOptOuts: { allow: ['Bash(ls:*)'] },
-        };
-        const result = resolveAgentDefaults({
-            baked,
-            state,
-            onDisk: undefined,
-            team: undefined,
-        });
-        expect(result.newOptOutsAllow).toEqual(['Bash(ls:*)']);
-        expect(result.applicableAllow).not.toContain('Bash(ls:*)');
-    });
-    it('case 3 normal: deny side mirrors allow side', () => {
-        const state = {
-            lastInjected: { deny: ['Bash(rm -rf *)', 'Bash(sudo rm *)'] },
-            userOptOuts: { deny: [] },
-        };
-        const result = resolveAgentDefaults({
-            baked: { allow: [], deny: ['Bash(rm -rf *)', 'Bash(sudo rm *)'] },
-            state,
-            onDisk: { deny: ['Bash(rm -rf *)'] },
-            team: undefined,
-        });
-        expect(result.newOptOutsDeny).toEqual(['Bash(sudo rm *)']);
-        expect(result.applicableDeny).toEqual(['Bash(rm -rf *)']);
-        expect(result.managedDeny).toEqual(['Bash(rm -rf *)']);
-    });
-});

package/dist/agents/__tests__/detection.test.d.ts

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

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

@@ -1,89 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Force a Windows environment for Windows-only detection methods. The
-// `runAgentDetection` function bails out off Windows for `windows-appx` and
-// `windows-start-app`, so we have to pretend.
-vi.mock('os', async () => {
-    const actual = await vi.importActual('os');
-    return { ...actual, platform: vi.fn(() => 'win32') };
-});
-const execBehaviors = [];
-let defaultBehavior = { kind: 'success' };
-vi.mock('child_process', () => ({
-    // promisify(execFile) drives this: the last argument is always the
-    // (err, stdout, stderr) callback regardless of whether options are passed.
-    execFile: (...args) => {
-        const cb = args[args.length - 1];
-        const behavior = execBehaviors.shift() ?? defaultBehavior;
-        const finish = (b) => {
-            if (b.kind === 'success')
-                cb(null, '', '');
-            else if (b.kind === 'fail')
-                cb(new Error('exit 1'), '', '');
-        };
-        if (behavior.kind === 'delay') {
-            setTimeout(() => finish({ kind: behavior.result }), behavior.ms);
-        }
-        else {
-            finish(behavior);
-        }
-    },
-}));
-vi.mock('../../utils/which.js', () => ({
-    whichBinary: vi.fn((name) => (name === 'present-binary' ? `/usr/bin/${name}` : null)),
-}));
-import { runAgentDetection } from '../detection.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-    execBehaviors.length = 0;
-    defaultBehavior = { kind: 'success' };
-});
-describe('runAgentDetection', () => {
-    it('reports binary detection via whichBinary', async () => {
-        expect(await runAgentDetection({ method: 'binary', target: 'present-binary' })).toBe(true);
-        expect(await runAgentDetection({ method: 'binary', target: 'missing-binary' })).toBe(false);
-    });
-    it('reports false when a windows-appx probe exits non-zero', async () => {
-        defaultBehavior = { kind: 'fail' };
-        expect(await runAgentDetection({ method: 'windows-appx', target: 'Some.Package' })).toBe(false);
-    });
-    it('reports true when any windows-appx probe succeeds', async () => {
-        // First two probes fail, third succeeds — the function should still
-        // return true because we union with Promise.all + .some(Boolean).
-        execBehaviors.push({ kind: 'fail' }, { kind: 'fail' }, { kind: 'success' });
-        expect(await runAgentDetection({ method: 'windows-appx', target: ['A', 'B', 'C'] })).toBe(true);
-    });
-    it('runs windows-appx probes in parallel (wall time ≈ slowest probe, not sum)', async () => {
-        // Each probe takes 80ms. Six probes serialized = ~480ms; parallel = ~80ms.
-        // Allow slack for CI noise but enough to catch a regression to sync execution.
-        defaultBehavior = { kind: 'delay', ms: 80, result: 'fail' };
-        const start = Date.now();
-        const result = await runAgentDetection({
-            method: 'windows-appx',
-            target: ['A', 'B', 'C', 'D', 'E', 'F'],
-        });
-        const elapsed = Date.now() - start;
-        expect(result).toBe(false);
-        expect(elapsed).toBeLessThan(300);
-    });
-    it('any combinator returns true on first hit', async () => {
-        expect(await runAgentDetection({
-            method: 'any',
-            target: [
-                { method: 'binary', target: 'missing-binary' },
-                { method: 'binary', target: 'present-binary' },
-            ],
-        })).toBe(true);
-    });
-    it('any combinator returns false when every probe misses', async () => {
-        expect(await runAgentDetection({
-            method: 'any',
-            target: [
-                { method: 'binary', target: 'missing-binary' },
-                { method: 'binary', target: 'also-missing' },
-            ],
-        })).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/__tests__/graceful-degradation.test.d.ts

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

package/dist/agents/__tests__/graceful-degradation.test.js

@@ -1,129 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('fs', () => ({
-    existsSync: vi.fn(() => false),
-    readFileSync: vi.fn(() => { throw new Error('ENOENT'); }),
-    readdirSync: vi.fn(() => []),
-    statSync: vi.fn(() => { throw new Error('ENOENT'); }),
-    mkdirSync: vi.fn(),
-    writeFileSync: vi.fn(),
-}));
-vi.mock('os', () => ({
-    homedir: vi.fn(() => '/nonexistent/home'),
-    platform: vi.fn(() => 'darwin'),
-}));
-vi.mock('child_process', () => ({
-    execFileSync: vi.fn(() => { throw new Error('ENOENT'); }),
-    // detection.ts wraps execFile via util.promisify; provide the callback
-    // shape so the import doesn't blow up even though no test here exercises it.
-    execFile: vi.fn((..._args) => {
-        const cb = _args[_args.length - 1];
-        cb(new Error('ENOENT'));
-    }),
-}));
-vi.mock('../../utils/sqlite.js', () => ({
-    querySqlite: vi.fn(() => ''),
-    openWritableSqlite: vi.fn(() => null),
-    sqliteAvailable: vi.fn(() => false),
-    sqliteFlavor: vi.fn(() => null),
-}));
-vi.mock('smol-toml', () => ({
-    parse: vi.fn(() => ({})),
-    stringify: vi.fn(() => ''),
-}));
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { homedir } from 'os';
-import { execFileSync } from 'child_process';
-import { ClaudeCodeAdapter } from '../claude-code.js';
-import { ClaudeDesktopAdapter } from '../claude-desktop.js';
-import { CursorAdapter } from '../cursor.js';
-import { CodexAdapter } from '../codex.js';
-const adapters = [
-    { name: 'claude-code', adapter: new ClaudeCodeAdapter() },
-    { name: 'claude-desktop', adapter: new ClaudeDesktopAdapter() },
-    { name: 'cursor', adapter: new CursorAdapter() },
-    { name: 'codex', adapter: new CodexAdapter() },
-];
-beforeEach(() => {
-    vi.clearAllMocks();
-    // Default: everything fails
-    vi.mocked(homedir).mockReturnValue('/nonexistent/home');
-    vi.mocked(existsSync).mockReturnValue(false);
-    vi.mocked(readFileSync).mockImplementation(() => { throw new Error('ENOENT'); });
-    vi.mocked(readdirSync).mockReturnValue([]);
-    vi.mocked(statSync).mockImplementation(() => { throw new Error('ENOENT'); });
-    vi.mocked(execFileSync).mockImplementation(() => { throw new Error('ENOENT'); });
-});
-describe('Graceful degradation: all adapters return null on errors', () => {
-    for (const { name, adapter } of adapters) {
-        describe(`${name} adapter`, () => {
-            it('readUsageStats returns null when homedir points to nonexistent path', async () => {
-                vi.mocked(homedir).mockReturnValue('/totally/nonexistent/path');
-                vi.mocked(existsSync).mockReturnValue(false);
-                const result = await adapter.readUsageStats(null);
-                expect(result).toBeNull();
-            });
-            it('readUsageStats returns null when existsSync throws', async () => {
-                vi.mocked(existsSync).mockImplementation(() => {
-                    throw new Error('Unexpected filesystem error');
-                });
-                const result = await adapter.readUsageStats(null);
-                expect(result).toBeNull();
-            });
-            it('readUsageStats returns null when readFileSync throws EACCES', async () => {
-                vi.mocked(existsSync).mockReturnValue(true);
-                vi.mocked(readFileSync).mockImplementation(() => {
-                    const err = new Error('EACCES: permission denied');
-                    err.code = 'EACCES';
-                    throw err;
-                });
-                vi.mocked(readdirSync).mockImplementation(() => {
-                    const err = new Error('EACCES: permission denied');
-                    err.code = 'EACCES';
-                    throw err;
-                });
-                const result = await adapter.readUsageStats(null);
-                expect(result).toBeNull();
-            });
-            it('readUsageStats never throws even on unexpected errors', async () => {
-                vi.mocked(existsSync).mockImplementation(() => {
-                    throw new TypeError('Cannot read properties of undefined');
-                });
-                // Must not throw, must return null
-                await expect(adapter.readUsageStats(null)).resolves.toBeNull();
-            });
-            if (adapter.readVersion) {
-                it('readVersion returns null when command/file not found', async () => {
-                    vi.mocked(execFileSync).mockImplementation(() => {
-                        throw new Error('ENOENT: command not found');
-                    });
-                    vi.mocked(existsSync).mockReturnValue(false);
-                    const result = await adapter.readVersion();
-                    expect(result).toBeNull();
-                });
-            }
-        });
-    }
-    // Claude Code is the only adapter with readSkillUsage
-    describe('claude-code readSkillUsage', () => {
-        const ccAdapter = new ClaudeCodeAdapter();
-        it('readSkillUsage returns null when skills dir does not exist', async () => {
-            vi.mocked(existsSync).mockReturnValue(false);
-            const result = await ccAdapter.readSkillUsage(null);
-            expect(result).toBeNull();
-        });
-        it('readSkillUsage returns null when readdirSync throws', async () => {
-            vi.mocked(existsSync).mockReturnValue(true);
-            vi.mocked(readdirSync).mockImplementation(() => {
-                throw new Error('EACCES: permission denied');
-            });
-            const result = await ccAdapter.readSkillUsage(null);
-            expect(result).toBeNull();
-        });
-        it('readSkillUsage never throws even on unexpected errors', async () => {
-            vi.mocked(existsSync).mockImplementation(() => {
-                throw new TypeError('Unexpected error');
-            });
-            await expect(ccAdapter.readSkillUsage(null)).resolves.toBeNull();
-        });
-    });
-});

package/dist/agents/__tests__/instruction-hint.test.d.ts

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

package/dist/agents/__tests__/instruction-hint.test.js

@@ -1,69 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { writeHintToFile } from '../utils/instruction-hint.js';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-let testDir;
-beforeEach(() => {
-    testDir = join(tmpdir(), `runwork-hint-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(testDir, { recursive: true });
-});
-afterEach(() => {
-    // Clean up
-    try {
-        const { rmSync } = require('fs');
-        rmSync(testDir, { recursive: true, force: true });
-    }
-    catch { /* ignore */ }
-});
-describe('writeHintToFile', () => {
-    it('creates new file with hint', () => {
-        const filePath = join(testDir, 'CLAUDE.md');
-        writeHintToFile(filePath, '<!-- runwork:start -->\n## Runwork\nHello\n<!-- runwork:end -->');
-        const content = readFileSync(filePath, 'utf-8');
-        expect(content).toContain('## Runwork');
-        expect(content).toContain('Hello');
-    });
-    it('appends to existing file', () => {
-        const filePath = join(testDir, 'CLAUDE.md');
-        writeFileSync(filePath, '# My Instructions\n\nDo stuff.\n');
-        writeHintToFile(filePath, '<!-- runwork:start -->\n## Runwork\nHello\n<!-- runwork:end -->');
-        const content = readFileSync(filePath, 'utf-8');
-        expect(content).toContain('# My Instructions');
-        expect(content).toContain('Do stuff.');
-        expect(content).toContain('## Runwork');
-        expect(content).toContain('Hello');
-    });
-    it('replaces existing runwork section', () => {
-        const filePath = join(testDir, 'CLAUDE.md');
-        writeFileSync(filePath, [
-            '# My Instructions',
-            '',
-            '<!-- runwork:start -->',
-            '## Runwork',
-            'Old content',
-            '<!-- runwork:end -->',
-            '',
-            '# Other stuff',
-        ].join('\n'));
-        writeHintToFile(filePath, '<!-- runwork:start -->\n## Runwork\nNew content\n<!-- runwork:end -->');
-        const content = readFileSync(filePath, 'utf-8');
-        expect(content).toContain('New content');
-        expect(content).not.toContain('Old content');
-        expect(content).toContain('# My Instructions');
-        expect(content).toContain('# Other stuff');
-    });
-    it('creates parent directories', () => {
-        const filePath = join(testDir, 'nested', 'dir', 'CLAUDE.md');
-        writeHintToFile(filePath, '<!-- runwork:start -->\nTest\n<!-- runwork:end -->');
-        expect(existsSync(filePath)).toBe(true);
-        expect(readFileSync(filePath, 'utf-8')).toContain('Test');
-    });
-    it('preserves content before and after markers', () => {
-        const filePath = join(testDir, 'CLAUDE.md');
-        writeFileSync(filePath, 'BEFORE\n<!-- runwork:start -->\nold\n<!-- runwork:end -->\nAFTER');
-        writeHintToFile(filePath, '<!-- runwork:start -->\nnew\n<!-- runwork:end -->');
-        const content = readFileSync(filePath, 'utf-8');
-        expect(content).toBe('BEFORE\n<!-- runwork:start -->\nnew\n<!-- runwork:end -->\nAFTER');
-    });
-});

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

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