runwork 0.9.0 → 0.9.2

package/dist/agents/registry.js

@@ -1,14 +1,17 @@
 /**
- * Shared agent registry data.
+ * CLI-side agent registry entry point.
  *
- * Source of truth: packages/runwork-desktop/src/lib/agent-registry.ts
- * When adding new agents, update both files.
- *
- * This is a data-only file -- no platform-specific helpers.
- * The CLI uses Node's process.platform for detection.
+ * The data and browser-safe types / lookups live in `./registry-data.ts` so
+ * that the desktop package can import them without pulling in Node-only
+ * modules. This file keeps the existing public surface for CLI callers by
+ * re-exporting everything from the data module and adding the Node-only path
+ * resolvers used by the generic adapter and `sync` command.
  */
 import { platform, homedir } from 'os';
 import { join } from 'path';
+// Re-export types, data, and browser-safe lookups so every existing CLI
+// caller keeps working unchanged (`import { getRegistryAgent, ... } from './registry.js'`).
+export * from './registry-data.js';
 function getNodePlatform() {
     const p = platform();
     if (p === 'darwin')
@@ -31,189 +34,3 @@ export function resolveToAbsolute(ps, scope) {
         ? join(homedir(), resolved)
         : join(process.cwd(), resolved);
 }
-// ---------------------------------------------------------------------------
-// Registry
-// ---------------------------------------------------------------------------
-const AGENT_REGISTRY = [
-    // === First-class agents (have custom adapters in CLI) ===
-    {
-        slug: 'claude-code',
-        name: 'Claude Code',
-        description: "Anthropic's AI coding agent for the terminal",
-        category: 'cli',
-        detection: { method: 'binary', target: 'claude' },
-        skillsPaths: { global: '.claude/skills', project: '.claude/skills' },
-        mcpConfigPath: '.claude/settings.json',
-        instructionFile: { global: '.claude/CLAUDE.md', project: '.claude/CLAUDE.md' },
-        mcpConfigKey: 'mcpServers',
-        firstClass: true,
-    },
-    {
-        slug: 'claude-desktop',
-        name: 'Claude Desktop',
-        aliases: ['Claude Desktop (Cowork)', 'Cowork'],
-        description: 'Claude as a desktop application',
-        category: 'desktop',
-        detection: {
-            method: 'path',
-            target: {
-                macos: 'Library/Application Support/Claude/claude_desktop_config.json',
-                windows: 'AppData/Roaming/Claude/claude_desktop_config.json',
-                linux: '.config/Claude/claude_desktop_config.json',
-            },
-        },
-        skillsPaths: { global: '.claude/skills', project: '.claude/skills' },
-        mcpConfigPath: {
-            macos: 'Library/Application Support/Claude/claude_desktop_config.json',
-            windows: 'AppData/Roaming/Claude/claude_desktop_config.json',
-            linux: '.config/Claude/claude_desktop_config.json',
-        },
-        mcpConfigKey: 'mcpServers',
-        firstClass: true,
-    },
-    {
-        slug: 'cursor',
-        name: 'Cursor',
-        description: 'AI-powered code editor',
-        category: 'ide',
-        detection: { method: 'binary', target: 'cursor' },
-        skillsPaths: { global: '.cursor/skills', project: '.cursor/skills' },
-        mcpConfigPath: '.cursor/mcp.json',
-        instructionFile: { project: '.cursor/rules/runwork.mdc' },
-        mcpConfigKey: 'mcpServers',
-        skillFormat: 'mdc',
-        firstClass: true,
-    },
-    {
-        slug: 'codex',
-        name: 'Codex CLI',
-        description: "OpenAI's AI coding agent for the terminal",
-        category: 'cli',
-        detection: { method: 'binary', target: 'codex' },
-        skillsPaths: { global: '.codex/skills', project: '.agents/skills' },
-        instructionFile: { global: '.codex/instructions.md', project: 'AGENTS.md' },
-        firstClass: true,
-    },
-    {
-        slug: 'windsurf',
-        name: 'Windsurf',
-        description: 'AI-powered code editor by Codeium',
-        category: 'ide',
-        detection: { method: 'binary', target: 'windsurf' },
-        skillsPaths: { global: '.codeium/windsurf/skills', project: '.windsurf/skills' },
-        mcpConfigPath: '.codeium/windsurf/mcp_config.json',
-        instructionFile: { global: '.codeium/windsurf/rules/runwork.md', project: '.windsurf/rules/runwork.md' },
-        mcpConfigKey: 'mcpServers',
-        skillFormat: 'windsurf-md',
-        firstClass: true,
-    },
-    {
-        slug: 'gemini',
-        name: 'Gemini CLI',
-        description: "Google's AI coding agent for the terminal",
-        category: 'cli',
-        detection: { method: 'binary', target: 'gemini' },
-        skillsPaths: { global: '.gemini/skills', project: '.gemini/skills' },
-        mcpConfigPath: '.gemini/settings.json',
-        instructionFile: { global: '.gemini/GEMINI.md', project: 'GEMINI.md' },
-        mcpConfigKey: 'mcpServers',
-        firstClass: true,
-    },
-    // === Additional agents with some custom handling ===
-    {
-        slug: 'copilot-vscode',
-        name: 'GitHub Copilot (VS Code)',
-        description: "GitHub's AI pair programmer in VS Code",
-        category: 'extension',
-        detection: { method: 'binary', target: 'code' },
-        skillsPaths: { global: '.copilot/skills', project: '.github/skills' },
-        mcpConfigPath: '.vscode/mcp.json',
-        mcpConfigKey: 'servers',
-    },
-    {
-        slug: 'cline',
-        name: 'Cline',
-        description: 'Autonomous AI coding agent for VS Code',
-        category: 'extension',
-        detection: { method: 'binary', target: 'cline' },
-        skillsPaths: { global: '.agents/skills', project: '.agents/skills' },
-    },
-    {
-        slug: 'copilot-cli',
-        name: 'GitHub Copilot CLI',
-        description: 'GitHub Copilot in the terminal',
-        category: 'cli',
-        detection: { method: 'binary', target: 'gh' },
-        skillsPaths: { global: '.copilot/skills', project: '.github/skills' },
-        mcpConfigPath: '.copilot/mcp-config.json',
-        mcpConfigKey: 'mcpServers',
-    },
-    // === Community agents (from skillshare targets.yaml) ===
-    { slug: 'antigravity', name: 'Antigravity', description: "Google's Antigravity AI agent", category: 'cli', detection: { method: 'binary', target: 'antigravity' }, skillsPaths: { global: '.gemini/antigravity/skills', project: '.agent/skills' } },
-    { slug: 'amp', name: 'Amp', description: 'AI coding agent by Sourcegraph', category: 'cli', detection: { method: 'binary', target: 'amp' }, skillsPaths: { global: '.config/agents/skills', project: '.agents/skills' } },
-    { slug: 'adal', name: 'AdaL', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'adal' }, skillsPaths: { global: '.adal/skills', project: '.adal/skills' } },
-    { slug: 'astrbot', name: 'AstrBot', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'astrbot' }, skillsPaths: { global: '.astrbot/data/skills', project: 'data/skills' } },
-    { slug: 'augment', name: 'Augment', description: 'AI coding assistant', category: 'ide', detection: { method: 'binary', target: 'augment' }, skillsPaths: { global: '.augment/skills', project: '.augment/skills' } },
-    { slug: 'bob', name: 'Bob', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'bob' }, skillsPaths: { global: '.bob/skills', project: '.bob/skills' } },
-    { slug: 'codebuddy', name: 'CodeBuddy', description: 'AI coding assistant', category: 'cli', detection: { method: 'binary', target: 'codebuddy' }, skillsPaths: { global: '.codebuddy/skills', project: '.codebuddy/skills' } },
-    { slug: 'comate', name: 'Comate', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'comate' }, skillsPaths: { global: '.comate/skills', project: '.comate/skills' } },
-    { slug: 'commandcode', name: 'Command Code', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'commandcode' }, skillsPaths: { global: '.commandcode/skills', project: '.commandcode/skills' } },
-    { slug: 'continue', name: 'Continue', description: 'Open-source AI code assistant', category: 'extension', detection: { method: 'binary', target: 'continue' }, skillsPaths: { global: '.continue/skills', project: '.continue/skills' } },
-    { slug: 'cortex', name: 'Cortex', description: "Snowflake's AI coding agent", category: 'cli', detection: { method: 'binary', target: 'cortex' }, skillsPaths: { global: '.snowflake/cortex/skills', project: '.cortex/skills' } },
-    { slug: 'crush', name: 'Crush', description: 'AI agent by Charm', category: 'cli', detection: { method: 'binary', target: 'crush' }, skillsPaths: { global: '.config/crush/skills', project: '.crush/skills' } },
-    { slug: 'deepagents', name: 'Deep Agents', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'deepagents' }, skillsPaths: { global: '.deepagents/agent/skills', project: '.deepagents/skills' } },
-    { slug: 'droid', name: 'Droid', description: "Factory AI's coding agent", category: 'cli', detection: { method: 'binary', target: 'droid' }, skillsPaths: { global: '.factory/skills', project: '.factory/skills' } },
-    { slug: 'firebender', name: 'Firebender', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'firebender' }, skillsPaths: { global: '.firebender/skills', project: '.firebender/skills' } },
-    { slug: 'goose', name: 'Goose', description: 'AI coding agent by Block', category: 'cli', detection: { method: 'binary', target: 'goose' }, skillsPaths: { global: '.config/goose/skills', project: '.goose/skills' } },
-    { slug: 'hermes', name: 'Hermes', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'hermes' }, skillsPaths: { global: '.hermes/skills', project: '.hermes/skills' } },
-    { slug: 'iflow', name: 'iFlow CLI', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'iflow' }, skillsPaths: { global: '.iflow/skills', project: '.iflow/skills' } },
-    { slug: 'junie', name: 'Junie', description: 'JetBrains AI coding agent', category: 'ide', detection: { method: 'binary', target: 'junie' }, skillsPaths: { global: '.junie/skills', project: '.junie/skills' } },
-    { slug: 'kilocode', name: 'Kilo Code', description: 'AI coding agent', category: 'extension', detection: { method: 'binary', target: 'kilocode' }, skillsPaths: { global: '.kilocode/skills', project: '.kilocode/skills' } },
-    { slug: 'kimi', name: 'Kimi Code CLI', description: "Moonshot AI's coding agent", category: 'cli', detection: { method: 'binary', target: 'kimi' }, skillsPaths: { global: '.config/agents/skills', project: '.agents/skills' } },
-    { slug: 'kiro', name: 'Kiro', description: "AWS's AI coding agent", category: 'ide', detection: { method: 'binary', target: 'kiro' }, skillsPaths: { global: '.kiro/skills', project: '.kiro/skills' } },
-    { slug: 'kode', name: 'Kode', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'kode' }, skillsPaths: { global: '.kode/skills', project: '.kode/skills' } },
-    { slug: 'letta', name: 'Letta', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'letta' }, skillsPaths: { global: '.letta/skills', project: '.skills' } },
-    { slug: 'lingma', name: 'Lingma', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'lingma' }, skillsPaths: { global: '.lingma/skills', project: '.lingma/skills' } },
-    { slug: 'mcpjam', name: 'MCPJam', description: 'MCP-based AI agent', category: 'cli', detection: { method: 'binary', target: 'mcpjam' }, skillsPaths: { global: '.mcpjam/skills', project: '.mcpjam/skills' } },
-    { slug: 'mux', name: 'Mux', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'mux' }, skillsPaths: { global: '.mux/skills', project: '.mux/skills' } },
-    { slug: 'neovate', name: 'Neovate', description: 'AI coding agent for Neovim', category: 'extension', detection: { method: 'binary', target: 'neovate' }, skillsPaths: { global: '.neovate/skills', project: '.neovate/skills' } },
-    { slug: 'omp', name: 'Oh My Pi', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'omp' }, skillsPaths: { global: '.omp/agent/skills', project: '.omp/skills' } },
-    { slug: 'openclaw', name: 'OpenClaw', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'openclaw' }, skillsPaths: { global: '.openclaw/skills', project: 'skills' } },
-    { slug: 'opencode', name: 'OpenCode', description: 'Open-source AI coding agent', category: 'cli', detection: { method: 'binary', target: 'opencode' }, skillsPaths: { global: '.config/opencode/skills', project: '.opencode/skills' } },
-    { slug: 'openhands', name: 'OpenHands', description: 'Open-source AI coding agent', category: 'cli', detection: { method: 'binary', target: 'openhands' }, skillsPaths: { global: '.openhands/skills', project: '.openhands/skills' } },
-    { slug: 'pi', name: 'Pi', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'pi' }, skillsPaths: { global: '.pi/agent/skills', project: '.pi/skills' } },
-    { slug: 'pochi', name: 'Pochi', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'pochi' }, skillsPaths: { global: '.pochi/skills', project: '.pochi/skills' } },
-    { slug: 'purecode', name: 'PureCode AI', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'purecode' }, skillsPaths: { global: '.purecode/skills', project: '.agents/skills' } },
-    { slug: 'qoder', name: 'Qoder', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'qoder' }, skillsPaths: { global: '.qoder/skills', project: '.qoder/skills' } },
-    { slug: 'qwen', name: 'Qwen Code', description: "Alibaba's AI coding agent", category: 'cli', detection: { method: 'binary', target: 'qwen' }, skillsPaths: { global: '.qwen/skills', project: '.qwen/skills' } },
-    { slug: 'roo', name: 'Roo Code', description: 'AI coding agent', category: 'extension', detection: { method: 'binary', target: 'roo' }, skillsPaths: { global: '.roo/skills', project: '.roo/skills' } },
-    { slug: 'trae', name: 'Trae', description: 'ByteDance AI coding IDE', category: 'ide', detection: { method: 'binary', target: 'trae' }, skillsPaths: { global: '.trae/skills', project: '.trae/skills' } },
-    { slug: 'mistral-vibe', name: 'Mistral Vibe', description: "Mistral's AI coding agent", category: 'cli', detection: { method: 'binary', target: 'vibe' }, skillsPaths: { global: '.vibe/skills', project: '.vibe/skills' } },
-    { slug: 'verdent', name: 'Verdent', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'verdent' }, skillsPaths: { global: '.verdent/skills', project: '.verdent/skills' } },
-    { slug: 'warp', name: 'Warp AI', description: 'AI-powered terminal', category: 'cli', detection: { method: 'path', target: { macos: '/Applications/Warp.app', linux: '/usr/bin/warp-terminal' } }, skillsPaths: { global: '.agents/skills', project: '.agents/skills' } },
-    { slug: 'witsy', name: 'Witsy', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'witsy' }, skillsPaths: { global: '.agents/skills', project: '.agents/skills' } },
-    { slug: 'zencoder', name: 'Zencoder', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'zencoder' }, skillsPaths: { global: '.zencoder/skills', project: '.zencoder/skills' } },
-    { slug: 'replit', name: 'Replit', description: 'AI-powered coding platform', category: 'ide', detection: { method: 'binary', target: 'replit' }, skillsPaths: { global: '.config/agents/skills', project: '.agents/skills' } },
-];
-// ---------------------------------------------------------------------------
-// Index (built once)
-// ---------------------------------------------------------------------------
-const slugIndex = new Map();
-for (const agent of AGENT_REGISTRY) {
-    slugIndex.set(agent.slug, agent);
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export function getRegistryAgent(slug) {
-    return slugIndex.get(slug);
-}
-export function getRegistryAgents() {
-    return AGENT_REGISTRY;
-}
-export function getFirstClassSlugs() {
-    return AGENT_REGISTRY.filter(a => a.firstClass).map(a => a.slug);
-}
-export function getCustomAdapterSlugs() {
-    return new Set(['claude-code', 'claude-desktop', 'cursor', 'windsurf', 'codex', 'cline', 'gemini']);
-}

package/dist/commands/dev.js

@@ -35,6 +35,65 @@ function readConfig() {
     }
     return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
 }
+// Files the CLI cannot function without and which the user did not author.
+// `.runwork.json` is the local app identity; `blueprint.json` is the app's
+// canonical feature definition; `.gitignore` keeps caches out of git. If a
+// sync from the remote silently removes any of these (which has happened
+// when a server-side agent commits with a stale index — see
+// worker/agents/git/git.ts), restoring from a pre-sync snapshot keeps the
+// project usable and unblocks `runwork deploy`.
+const CRITICAL_FILES = ['.runwork.json', 'blueprint.json', '.gitignore'];
+function snapshotCriticalFiles(cwd) {
+    const snapshots = [];
+    for (const rel of CRITICAL_FILES) {
+        const abs = join(cwd, rel);
+        if (!existsSync(abs))
+            continue;
+        try {
+            snapshots.push({ path: rel, contents: readFileSync(abs, 'utf-8') });
+        }
+        catch {
+            // Best-effort: skip unreadable files.
+        }
+    }
+    return snapshots;
+}
+function restoreMissingCriticalFiles(cwd, snapshots) {
+    const restored = [];
+    for (const snap of snapshots) {
+        const abs = join(cwd, snap.path);
+        if (existsSync(abs))
+            continue;
+        try {
+            writeFileSync(abs, snap.contents, 'utf-8');
+            restored.push(snap.path);
+        }
+        catch {
+            // Best-effort: skip files we cannot write back.
+        }
+    }
+    return restored;
+}
+function commitAndPushRestoredFiles(cwd, files) {
+    if (files.length === 0)
+        return false;
+    try {
+        execFileSync('git', ['add', '--', ...files], { cwd, stdio: 'pipe' });
+        execFileSync('git', ['commit', '-m', 'chore: restore critical files removed by sync'], { cwd, stdio: 'pipe' });
+    }
+    catch {
+        return false;
+    }
+    try {
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        // Push failures are non-fatal: the local copy is restored, and the
+        // restoration commit will be pushed with the next auto-sync cycle.
+        return false;
+    }
+}
 export async function execDev(options) {
     const useJson = options?.json ?? false;
     const config = readConfig();
@@ -108,7 +167,26 @@ export async function execDev(options) {
     // Sync
     if (!useJson)
         console.log(dim('Syncing...'));
+    const criticalSnapshot = snapshotCriticalFiles(cwd);
     const syncResult = syncWithRemote(cwd);
+    const restoredCriticalFiles = restoreMissingCriticalFiles(cwd, criticalSnapshot);
+    if (restoredCriticalFiles.length > 0) {
+        const pushed = commitAndPushRestoredFiles(cwd, restoredCriticalFiles);
+        if (useJson) {
+            jsonLine({
+                event: 'sync_restored_critical_files',
+                files: restoredCriticalFiles,
+                pushed,
+                timestamp: ts(),
+            });
+        }
+        else {
+            console.warn(yellow(`  Sync removed critical file(s); restored: ${restoredCriticalFiles.join(', ')}`));
+            if (!pushed) {
+                console.warn(dim('  Restoration committed locally but not pushed; will retry on next auto-sync.'));
+            }
+        }
+    }
     if (useJson) {
         jsonLine({ event: 'startup', phase: 'sync', status: syncResult.status, pushed: syncResult.pushed, timestamp: ts() });
         if (syncResult.status === 'sync-failed') {

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.9.0";
+export declare const VERSION = "0.9.2";

package/dist/generated/version.js

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

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

@@ -67,6 +67,47 @@ describe('generateManifest()', () => {
         expect(Object.keys(manifest.files)).toHaveLength(1);
         expect(manifest.files['a.txt']).toBeDefined();
     });
+    it('skips .bun-cache directory by default (regression: hung dev startup)', async () => {
+        // Bun's per-project cache used to be walked recursively here. When it
+        // grew to ~1 GB / 25k+ files, generateManifest spent minutes hashing
+        // every file and starved the rest of `runwork dev`. The default
+        // ignore-matcher now skips .bun-cache/ even without a .gitignore.
+        const dir = makeTempDir('bun-cache');
+        writeFileSync(join(dir, 'a.txt'), 'hello');
+        mkdirSync(join(dir, '.bun-cache'));
+        writeFileSync(join(dir, '.bun-cache', 'pkg.tgz'), 'tarball');
+        mkdirSync(join(dir, '.bun-cache', 'react@19.0.0'));
+        writeFileSync(join(dir, '.bun-cache', 'react@19.0.0', 'index.js'), 'r');
+        const manifest = await generateManifest(dir);
+        expect(Object.keys(manifest.files)).toEqual(['a.txt']);
+    });
+    it('honors simple .gitignore directory entries (e.g. dist/, .next/, coverage)', async () => {
+        const dir = makeTempDir('gitignored-dirs');
+        writeFileSync(join(dir, '.gitignore'), 'dist/\n.next/\ncoverage\n');
+        writeFileSync(join(dir, 'a.txt'), 'hello');
+        mkdirSync(join(dir, 'dist'));
+        writeFileSync(join(dir, 'dist', 'bundle.js'), 'compiled');
+        mkdirSync(join(dir, '.next'));
+        writeFileSync(join(dir, '.next', 'build.json'), '{}');
+        mkdirSync(join(dir, 'coverage'));
+        writeFileSync(join(dir, 'coverage', 'lcov.info'), 'data');
+        const manifest = await generateManifest(dir);
+        const keys = Object.keys(manifest.files).sort();
+        expect(keys).toEqual(['.gitignore', 'a.txt']);
+    });
+    it('falls through to defaults when .gitignore patterns are too complex', async () => {
+        // The walker only honors simple directory/basename entries. Globbed
+        // patterns are skipped, so files matching them still appear in the
+        // manifest. This is acceptable: the goal is to avoid the runaway
+        // cases (huge gitignored caches), not to be a full gitignore matcher.
+        const dir = makeTempDir('complex-gitignore');
+        writeFileSync(join(dir, '.gitignore'), '*.local\nsrc/generated/\n');
+        writeFileSync(join(dir, 'a.txt'), 'hello');
+        writeFileSync(join(dir, 'config.local'), 'should-still-appear');
+        const manifest = await generateManifest(dir);
+        expect(manifest.files['a.txt']).toBeDefined();
+        expect(manifest.files['config.local']).toBeDefined();
+    });
     it('handles files with spaces in names', async () => {
         const dir = makeTempDir('spaces');
         writeFileSync(join(dir, 'hello world.txt'), 'content');
@@ -374,4 +415,32 @@ describe('detectUserEdits() edge cases', () => {
         const edits = await detectUserEdits(dir, manifest);
         expect(edits).not.toContain('config.txt');
     });
+    it('does not flag tracked file whose committed content differs from template manifest', async () => {
+        // Reproduces the post-`runwork clone` scenario: the manifest was
+        // generated from the pristine template, then the AI-customized
+        // version was overlaid via `git fetch` + `git checkout .` and is now
+        // committed at HEAD with no local edits. Method 3's scan would
+        // false-flag every such file on every clone if it didn't skip
+        // tracked files.
+        const dir = makeTempDir('clone-overlay');
+        initGitRepo(dir);
+        // Simulate: AI-customized version is committed at HEAD.
+        const overlaidContent = 'AI-customized content';
+        writeFileSync(join(dir, 'worker/agents.ts'.replace('/', '-')), 'placeholder');
+        const aiFilePath = 'agents.ts';
+        writeFileSync(join(dir, aiFilePath), overlaidContent);
+        execFileSync('git', ['add', '.'], { cwd: dir });
+        execFileSync('git', ['commit', '-m', 'overlay'], { cwd: dir });
+        // Manifest captured the PRISTINE template hash (different from the
+        // overlaid HEAD content). detectUserEdits must not treat this as a
+        // user edit.
+        const manifest = {
+            version: 1,
+            files: {
+                [aiFilePath]: 'sha256:pristine_template_hash_unrelated_to_disk',
+            },
+        };
+        const edits = await detectUserEdits(dir, manifest);
+        expect(edits).not.toContain(aiFilePath);
+    });
 });

package/dist/git/auto-commit.d.ts

@@ -1,4 +1,9 @@
 import type { ApiClient } from '../api/client.js';
+/**
+ * Basename-level ignore predicate using the static defaults only.
+ * Exposed for unit testing of the static defaults; the runtime watcher uses
+ * a richer matcher built from `.gitignore` (see watchAndAutoCommit).
+ */
 export declare function isIgnored(filePath: string): boolean;
 export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string, callbacks?: {
     onFileChange?: (relPath: string, pendingCount: number) => void;

package/dist/git/auto-commit.js

@@ -1,8 +1,9 @@
 import { execFileSync } from 'child_process';
 import { readFileSync } from 'fs';
 import { watch } from 'chokidar';
-import { basename, join, relative } from 'path';
+import { join, relative } from 'path';
 import { dim, cyan, yellow } from '../ui/colors.js';
+import { buildIgnoreSets, defaultIgnoreSets, isPathIgnored } from '../utils/ignore-matcher.js';
 let watcher = null;
 let fastSyncTimer = null;
 let gitTimer = null;
@@ -13,9 +14,6 @@ let activeCallbacks;
 const pendingFastSync = new Map();
 // Track files the user actually touched during this session (for git)
 const changedFiles = new Set();
-const SKIP_DIRS = new Set(['node_modules', '.git', '.runwork']);
-const SKIP_FILES = new Set(['.dev.vars', '.env']);
-const SKIP_EXTENSIONS = new Set(['.log']);
 // Binary extensions to skip in fast sync (git handles them fine)
 const BINARY_EXTENSIONS = new Set([
     '.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp', '.avif', '.svg',
@@ -24,21 +22,24 @@ const BINARY_EXTENSIONS = new Set([
     '.zip', '.tar', '.gz', '.br',
     '.pdf', '.wasm',
 ]);
+const STATIC_IGNORE_SETS = defaultIgnoreSets();
+/**
+ * Basename-level ignore predicate using the static defaults only.
+ * Exposed for unit testing of the static defaults; the runtime watcher uses
+ * a richer matcher built from `.gitignore` (see watchAndAutoCommit).
+ */
 export function isIgnored(filePath) {
-    const name = basename(filePath);
-    if (SKIP_DIRS.has(name))
-        return true;
-    if (SKIP_FILES.has(name))
-        return true;
-    const ext = name.lastIndexOf('.') >= 0 ? name.slice(name.lastIndexOf('.')) : '';
-    if (SKIP_EXTENSIONS.has(ext))
-        return true;
-    return false;
+    return isPathIgnored(filePath, STATIC_IGNORE_SETS);
 }
 export async function watchAndAutoCommit(directory, client, appId, callbacks) {
     activeCallbacks = callbacks;
+    // Build a project-scoped ignore matcher that includes simple patterns from
+    // the project's .gitignore in addition to the static defaults. Without
+    // this the watcher tries to descend into large gitignored caches such as
+    // `.bun-cache/` or `dist/` and bogs the CLI down on startup.
+    const ignoreSets = buildIgnoreSets(directory);
     watcher = watch(directory, {
-        ignored: isIgnored,
+        ignored: (p) => isPathIgnored(p, ignoreSets),
         persistent: true,
         ignoreInitial: true,
         awaitWriteFinish: {

package/dist/template/manifest.js

@@ -2,22 +2,26 @@ import { createHash } from 'crypto';
 import { execFileSync } from 'child_process';
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
 import { join, relative } from 'path';
-const SKIP_DIRS = new Set(['.git', 'node_modules', '.runwork']);
-const SKIP_FILES = new Set(['.dev.vars', '.env']);
+import { buildIgnoreSets } from '../utils/ignore-matcher.js';
 function sha256(data) {
     return 'sha256:' + createHash('sha256').update(data).digest('hex');
 }
-function walkDir(dir, base) {
+function walkDir(dir, base, sets) {
     const results = [];
     const entries = readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-        if (SKIP_DIRS.has(entry.name))
+        if (sets.dirs.has(entry.name))
             continue;
-        if (SKIP_FILES.has(entry.name))
+        if (sets.files.has(entry.name))
             continue;
+        if (entry.isFile()) {
+            const dotIndex = entry.name.lastIndexOf('.');
+            if (dotIndex >= 0 && sets.extensions.has(entry.name.slice(dotIndex)))
+                continue;
+        }
         const fullPath = join(dir, entry.name);
         if (entry.isDirectory()) {
-            results.push(...walkDir(fullPath, base));
+            results.push(...walkDir(fullPath, base, sets));
         }
         else if (entry.isFile()) {
             results.push(relative(base, fullPath));
@@ -27,7 +31,8 @@ function walkDir(dir, base) {
 }
 export async function generateManifest(dir) {
     const files = {};
-    const allFiles = walkDir(dir, dir);
+    const sets = buildIgnoreSets(dir);
+    const allFiles = walkDir(dir, dir, sets);
     for (const relPath of allFiles) {
         const content = readFileSync(join(dir, relPath));
         files[relPath] = sha256(content);
@@ -104,9 +109,27 @@ export async function detectUserEdits(dir, manifest) {
     // 3. Scan manifest files on disk directly — catches gitignored files that
     // git ls-files --exclude-standard would miss. If a template file was added
     // to .gitignore by the user and then modified, only this check detects it.
+    //
+    // Tracked files are excluded here because their state is fully described
+    // by Method 1 (`git diff HEAD`). After `runwork clone`, AI-customized
+    // versions of template files are committed at HEAD and would otherwise be
+    // false-flagged on every fresh clone.
+    const trackedFiles = new Set();
+    try {
+        const tracked = execFileSync('git', ['-c', 'core.quotePath=false', 'ls-files'], { cwd: dir, encoding: 'utf-8' }).trim();
+        for (const relPath of tracked.split('\n')) {
+            if (relPath)
+                trackedFiles.add(relPath);
+        }
+    }
+    catch {
+        // No git repo — every manifest file remains a candidate for Method 3.
+    }
     for (const [relPath, expectedHash] of Object.entries(manifest.files)) {
         if (edits.includes(relPath))
             continue;
+        if (trackedFiles.has(relPath))
+            continue;
         const filePath = join(dir, relPath);
         try {
             const content = readFileSync(filePath);

package/dist/utils/__tests__/ignore-matcher.test.d.ts

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