runwork 0.15.0 → 0.15.2

package/dist/agents/conversation-skills.js

@@ -1,229 +0,0 @@
-/**
- * Names of every skill the CLI ships as a built-in (written to user machines
- * on each sync from code, never pulled from or pushed to the workspace).
- *
- * Sync uses this list to:
- *   1. Skip these names when computing the local-vs-remote diff so they
- *      never appear in pull/push/conflict plans.
- *   2. Warn the user (and offer cleanup) if a workspace skill with the same
- *      name exists -- it would be shadowed by the built-in locally and is
- *      probably a stale duplicate.
- *
- * Keep this list in sync with: intro-skill.ts (`runwork`) and the two
- * `buildXConversationSkill` functions below.
- */
-export const BUILT_IN_SKILL_NAMES = [
-    'runwork',
-    'share-conversation',
-    'save-conversation',
-];
-/**
- * Built-in skills shipped by the runwork CLI on every sync. These are
- * fundamental capabilities every user should have regardless of which
- * workspace they belong to, so they live in the CLI codebase (like
- * the dynamic `runwork` intro skill in ./intro-skill.ts) rather than
- * as workspace-managed skills uploaded via the `save_skill` MCP tool.
- *
- *   share-conversation: hand off the current AI conversation to a teammate
- *   save-conversation:  personal checkpoint of the current AI conversation
- *
- * Both are paired with the CLI commands `runwork share-convo` and
- * `runwork save-convo`. The skill body teaches the host LLM how to compose
- * the verbatim transcript + metadata and invoke the CLI.
- */
-const SHARE_CONVERSATION_CONTENT = `# Share Conversation Skill
-
-This skill hands off the user's CURRENT AI conversation (the live chat you and the user are in) to a teammate so they can resume it natively in their own AI agent.
-
-## When to trigger
-
-The user said something like:
-- "share this convo with X"
-- "share this conversation with X@example.com"
-- "send this to Mehmet"
-- "hand off this thread to Alice"
-- "forward this conversation to user@motaword.com"
-
-X may be a workspace member name, an email, or a list. ASK if ambiguous.
-
-## What you must do
-
-**Step 1: Confirm the recipients.** Read the user's message, extract the email(s) or name(s). Confirm them back to the user before sending. Multiple recipients are allowed (comma-separated or multiple --to flags).
-
-**Step 2: Compose a VERBATIM transcript of this conversation.** Write a complete markdown transcription of everything that has happened in this chat session so far. CRITICAL RULES:
-
-- Transcribe EVERY message: user, assistant, tool calls, tool results.
-- DO NOT summarize. DO NOT abbreviate. DO NOT skip anything you think is unimportant.
-- Preserve the actual content of every assistant message, every Bash command, every Read result, every Edit, every Web search, every reasoning block you can recall, in chronological order.
-- Use this structure:
-
-\`\`\`markdown
-# Conversation: <one-line title>
-
-## Conversation
-
-### Turn 1 - User
-<user's exact message>
-
-### Turn 2 - Assistant
-<your exact response text>
-
-#### Tool call: Read
-**Input**: { "file_path": "..." }
-**Result**: <full result, truncated only if absolutely necessary>
-
-### Turn 3 - User
-...
-\`\`\`
-
-- If you literally cannot remember every single tool result word-for-word (e.g., very long files), include as much as you have in context. Note explicitly when content is partial: \`[truncated for brevity; original was N lines]\`.
-- The goal is full fidelity. If the context is too long, FAIL LOUDLY by telling the user "the conversation is too long to transcribe completely; please confirm you want me to proceed with a best-effort transcription" rather than silently dropping content.
-
-Write the transcript to a temp file: \`/tmp/runwork-share-transcript-<random>.md\`.
-
-**Step 3: Generate metadata.** Compose a JSON object with these fields based on this conversation's actual content:
-
-\`\`\`json
-{
-  "workMode": "coding | research | writing | planning | ops | communication | general",
-  "topicKeywords": ["3-5 short tags"],
-  "lastUserIntent": "one sentence describing what the user was trying to do at handoff time",
-  "primaryArtifacts": ["files / URLs / docs touched during the conversation"],
-  "openQuestions": ["unresolved questions or decisions at handoff time"],
-  "suggestedNextStep": "one sentence about what the recipient should do next",
-  "language": "programming or natural language used"
-}
-\`\`\`
-
-Write this to \`/tmp/runwork-share-metadata-<random>.json\`.
-
-**Step 4: Invoke the CLI.** Run:
-
-\`\`\`bash
-runwork share-convo \\
-  --to <email1> \\
-  --to <email2> \\
-  --transcript-file /tmp/runwork-share-transcript-<random>.md \\
-  --metadata-file /tmp/runwork-share-metadata-<random>.json \\
-  --title "<short title derived from the conversation>"
-\`\`\`
-
-The CLI auto-detects your host agent (Claude Code, Codex, etc.) and locates the native session file via \`$CLAUDE_CODE_SESSION_ID\` / \`$CODEX_THREAD_ID\` env vars. You typically don't need to pass \`--source-agent\` or \`--native-file\`.
-
-If the user provided a personal note for the recipient, also pass \`--note "<message>"\`.
-
-**Step 5: Tell the user.** Report the share ID and inbox URL returned by the CLI. Mention any non-workspace recipients that were invited.
-
-## Fallback: when the CLI is not available
-
-If \`runwork\` is not on PATH (rare; the CLI ships with workspace onboarding), use the Runwork MCP \`share_conversation\` tool instead. Pass the transcript content inline (lossier - no native bundle - but always works).
-
-## Safety
-
-- Never include credentials, API keys, or secrets in the transcript if you can identify them. Replace with \`[REDACTED]\`.
-- If the conversation contained sensitive customer data, confirm with the user before sharing.
-- Workspace permissions: non-member recipients trigger an invite, which requires the sender to have the \`members.invite\` permission (owner or admin). The CLI will error out clearly if not allowed.
-
-## What this skill is NOT for
-
-- Sharing files, apps, links, or screenshots. Use \`share-app\` or copy-paste.
-- Continuing a paused conversation yourself. Use \`runwork resume <id>\` after the recipient runs it.
-- Sharing a different conversation that's not the one you're currently in. The transcript is built from your live context.
-`;
-const SAVE_CONVERSATION_CONTENT = `# Save Conversation Skill
-
-This skill creates a personal checkpoint of the user's CURRENT AI conversation. The user is the sole recipient; no notifications are sent to anyone else. They can resume it later in any of their AI agents on any of their machines.
-
-## When to trigger
-
-The user said something like:
-- "save this convo"
-- "checkpoint this"
-- "bookmark this conversation"
-- "save this for later"
-- "save this for tomorrow"
-- "stash this so I can pick it up at home"
-
-If the user mentions ANOTHER PERSON or an email, use the \`share-conversation\` skill instead, not this one.
-
-## What you must do
-
-**Step 1: Confirm the intent.** A simple confirmation is enough: "Saving this conversation as a personal checkpoint."
-
-**Step 2: Compose a VERBATIM transcript of this conversation.** Same rules as the share-conversation skill - faithful, complete, no summarization. Write to \`/tmp/runwork-save-transcript-<random>.md\`.
-
-\`\`\`markdown
-# Conversation: <one-line title>
-
-## Conversation
-
-### Turn 1 - User
-<exact user message>
-
-### Turn 2 - Assistant
-<exact assistant response>
-
-#### Tool call: <name>
-**Input**: ...
-**Result**: ...
-\`\`\`
-
-**Step 3: Generate metadata.** Same shape as share-conversation:
-
-\`\`\`json
-{
-  "workMode": "coding | research | writing | planning | ops | communication | general",
-  "topicKeywords": ["3-5 tags"],
-  "lastUserIntent": "what the user was trying to do at checkpoint time",
-  "primaryArtifacts": ["files / URLs touched"],
-  "openQuestions": ["unresolved items"],
-  "suggestedNextStep": "what to do when picking back up",
-  "language": "programming or natural language"
-}
-\`\`\`
-
-Write to \`/tmp/runwork-save-metadata-<random>.json\`.
-
-**Step 4: Invoke the CLI.**
-
-\`\`\`bash
-runwork save-convo \\
-  --transcript-file /tmp/runwork-save-transcript-<random>.md \\
-  --metadata-file /tmp/runwork-save-metadata-<random>.json \\
-  --title "<short title>"
-\`\`\`
-
-If the user provided a personal note ("save this with note: pick up after lunch"), pass \`--note "<message>"\`.
-
-**Step 5: Tell the user.** Report the share ID. Mention they can resume from any machine with:
-
-\`\`\`
-runwork resume <share-id>
-\`\`\`
-
-## Fallback: when the CLI is not available
-
-Use the Runwork MCP \`save_conversation\` tool with the transcript inline.
-
-## What this skill is NOT for
-
-- Sharing with another person. Use \`share-conversation\`.
-- Saving files or code. Use the file system or git.
-- Note-taking. Use a notes app or write to disk directly.
-`;
-export function buildShareConversationSkill() {
-    return {
-        name: 'share-conversation',
-        filename: 'share-conversation',
-        content: SHARE_CONVERSATION_CONTENT,
-        description: 'TRIGGERS when the user asks to share, send, hand off, or forward the CURRENT AI conversation (the live chat you are in right now) to a teammate by name or email. Examples: "share this convo with oytun@motaword.com", "send this conversation to Mehmet", "hand off this thread to Alice". Use ONLY when the user wants the OTHER PERSON to be able to continue this exact conversation in their own AI agent. Do NOT trigger for sharing files, apps, links, or unrelated content. For personal checkpoint (sharing to yourself), use the `save-conversation` skill instead.',
-    };
-}
-export function buildSaveConversationSkill() {
-    return {
-        name: 'save-conversation',
-        filename: 'save-conversation',
-        content: SAVE_CONVERSATION_CONTENT,
-        description: 'TRIGGERS when the user wants to save, checkpoint, bookmark, or stash the CURRENT AI conversation for themselves (not for a teammate). Examples: "save this convo", "checkpoint this", "bookmark this conversation", "save this for later", "save this so I can pick it up tomorrow", "save this for my other machine". Use ONLY when the user is the sole intended recipient. For sharing with a teammate (different person), use the `share-conversation` skill instead.',
-    };
-}

package/dist/agents/cursor.d.ts

@@ -1,48 +0,0 @@
-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[];
-export declare class CursorAdapter implements AgentAdapter {
-    name: string;
-    slug: string;
-    mcpProvidesSkills: boolean;
-    detect(): Promise<boolean>;
-    supportsMcpScope(_scope: 'project' | 'user'): boolean;
-    supportsSkills(): boolean;
-    writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
-    writeSkills(skills: SkillFile[], 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', baseline?: {
-        allow?: string[];
-        deny?: string[];
-    }): Promise<void>;
-    readManagedBlock(_scope: 'project' | 'user'): Promise<{
-        allow?: string[];
-        deny?: string[];
-    } | undefined>;
-    /**
-     * Merge domains into Cursor's sandbox network policy (~/.cursor/sandbox.json).
-     * Schema per https://cursor.com/docs/reference/sandbox:
-     *   { "networkPolicy": { "default": "allow" | "deny", "allow": [...], "deny": [...] } }
-     * Only appends to the allow list; never flips `default` (respects user's existing policy).
-     * If the user has `default: allow`, all traffic is already permitted and entries are harmless.
-     * If the user has `default: deny`, our entries take effect and unblock Runwork.
-     */
-    private mergeSandboxAllowlist;
-    cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
-    readUsageStats(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
-    readVersion(): Promise<string | null>;
-}

package/dist/agents/cursor.js

@@ -1,324 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { homedir, platform } from 'os';
-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;
-}
-export class CursorAdapter {
-    name = 'Cursor';
-    slug = 'cursor';
-    mcpProvidesSkills = true;
-    async detect() {
-        const os = platform();
-        if (os === 'darwin' && existsSync('/Applications/Cursor.app'))
-            return true;
-        return !!whichBinary('cursor');
-    }
-    supportsMcpScope(_scope) {
-        return true;
-    }
-    supportsSkills() {
-        return true;
-    }
-    async writeMcpServers(servers, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.cursor', 'mcp.json')
-            : join(homedir(), '.cursor', 'mcp.json');
-        const entries = {};
-        for (const s of servers) {
-            entries[s.name] = {
-                url: s.url,
-                ...(s.headers ? { headers: s.headers } : {}),
-            };
-        }
-        mergeJsonMcpServers(filePath, entries, 'mcpServers');
-    }
-    async writeSkills(skills, scope) {
-        if (scope === 'user')
-            return;
-        const rulesDir = join(process.cwd(), '.cursor', 'rules');
-        mkdirSync(rulesDir, { recursive: true });
-        for (const skill of skills) {
-            const mdcContent = `---
-description: "${skill.description}"
-alwaysApply: false
----
-
-${skill.content}`;
-            writeFileSync(join(rulesDir, `${skill.filename}.mdc`), mdcContent);
-        }
-    }
-    async writeInstructionHint(hint, scope) {
-        // Cursor uses rules files, not a central instruction file
-        // Write as a rule file that's always loaded
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.cursor', 'rules', 'runwork.mdc')
-            : join(homedir(), '.cursor', 'rules', 'runwork.mdc');
-        const mdcContent = `---\ndescription: "Runwork workspace connection"\nalwaysApply: true\n---\n\n${hint}`;
-        mkdirSync(join(filePath, '..'), { recursive: true });
-        writeFileSync(filePath, mdcContent);
-    }
-    async writeTeamInstructions(instructions, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.cursor', 'rules', 'runwork-team.mdc')
-            : join(homedir(), '.cursor', 'rules', 'runwork-team.mdc');
-        const mdcContent = `---\ndescription: "Team instructions from Runwork workspace"\nalwaysApply: true\n---\n\n${instructions}`;
-        mkdirSync(join(filePath, '..'), { recursive: true });
-        writeFileSync(filePath, mdcContent);
-    }
-    // ── Agent config (model, permissions via SQLite) ────────────────────
-    async writeAgentConfig(config, scope, baseline) {
-        if (scope !== 'user')
-            return;
-        // Sandbox network allowlist: merge into ~/.cursor/cli-config.json
-        if (config.networkAllowlist?.length) {
-            this.mergeSandboxAllowlist(config.networkAllowlist);
-        }
-        const os = platform();
-        let globalDbPath;
-        if (os === 'darwin') {
-            globalDbPath = join(homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
-        }
-        else if (os === 'win32') {
-            globalDbPath = join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Cursor', 'User', 'globalStorage', 'state.vscdb');
-        }
-        else {
-            globalDbPath = join(homedir(), '.config', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
-        }
-        if (!existsSync(globalDbPath))
-            return;
-        const db = openWritableSqlite(globalDbPath);
-        if (!db) {
-            // SQLite runtime unavailable (older Node without node:sqlite, or not running
-            // under Bun) or the database is locked/inaccessible. Cursor config write is
-            // best-effort, so we silently skip.
-            return;
-        }
-        try {
-            const storageKey = 'src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser';
-            const row = db.prepare(`SELECT value FROM ItemTable WHERE key = ?`).get(storageKey);
-            if (!row?.value)
-                return;
-            const data = JSON.parse(row.value);
-            if (config.modelPreference) {
-                if (!data.aiSettings)
-                    data.aiSettings = {};
-                data.aiSettings.composerModel = config.modelPreference;
-            }
-            if (config.permissionRules && data.composerState) {
-                if (config.permissionRules.allow) {
-                    data.composerState.yoloCommandAllowlist = mergeMarkerless(data.composerState.yoloCommandAllowlist ?? [], baseline?.allow ?? [], config.permissionRules.allow);
-                }
-                if (config.permissionRules.deny) {
-                    data.composerState.yoloCommandDenylist = mergeMarkerless(data.composerState.yoloCommandDenylist ?? [], baseline?.deny ?? [], config.permissionRules.deny);
-                }
-            }
-            try {
-                db.prepare(`UPDATE ItemTable SET value = ? WHERE key = ?`).run(JSON.stringify(data), storageKey);
-            }
-            catch {
-                // Write failed (db locked while Cursor is running). Best-effort skip.
-            }
-        }
-        finally {
-            db.close();
-        }
-    }
-    async readManagedBlock(_scope) {
-        // Cursor's yoloCommandAllowlist has no marker — there's no way to read a
-        // managed-subset from disk. The sync loop relies on the `baseline` arg
-        // (state.lastInjected) passed into writeAgentConfig instead.
-        return undefined;
-    }
-    /**
-     * Merge domains into Cursor's sandbox network policy (~/.cursor/sandbox.json).
-     * Schema per https://cursor.com/docs/reference/sandbox:
-     *   { "networkPolicy": { "default": "allow" | "deny", "allow": [...], "deny": [...] } }
-     * Only appends to the allow list; never flips `default` (respects user's existing policy).
-     * If the user has `default: allow`, all traffic is already permitted and entries are harmless.
-     * If the user has `default: deny`, our entries take effect and unblock Runwork.
-     */
-    mergeSandboxAllowlist(domains) {
-        const configPath = join(homedir(), '.cursor', 'sandbox.json');
-        try {
-            const config = readJsonConfig(configPath);
-            if (!config.networkPolicy)
-                config.networkPolicy = {};
-            const policy = config.networkPolicy;
-            const existing = (policy.allow ?? []);
-            const merged = new Set(existing);
-            for (const domain of domains) {
-                merged.add(domain);
-            }
-            policy.allow = [...merged];
-            writeJsonConfig(configPath, config);
-        }
-        catch {
-            // Best-effort: sandbox config write is non-fatal
-        }
-    }
-    // ── Cleanup (uninstall) ────────────────────────────────────────────
-    async cleanup(scope, manifest) {
-        // 1. Remove MCP entries
-        const mcpPath = scope === 'project'
-            ? join(process.cwd(), '.cursor', 'mcp.json')
-            : join(homedir(), '.cursor', 'mcp.json');
-        removeRunworkMcpServers(mcpPath, 'mcpServers');
-        // 2. Remove rule files (skills, hint, team instructions)
-        const rulesDir = scope === 'project'
-            ? join(process.cwd(), '.cursor', 'rules')
-            : join(homedir(), '.cursor', 'rules');
-        if (existsSync(rulesDir)) {
-            // Remove runwork.mdc and runwork-team.mdc
-            for (const file of ['runwork.mdc', 'runwork-team.mdc']) {
-                const filePath = join(rulesDir, file);
-                if (existsSync(filePath)) {
-                    try {
-                        unlinkSync(filePath);
-                    }
-                    catch { /* best-effort */ }
-                }
-            }
-            // Remove only skill .mdc files that we synced
-            if (manifest?.skillFilenames.length) {
-                const allowed = new Set(manifest.skillFilenames.map(f => `${f}.mdc`));
-                for (const entry of readdirSync(rulesDir)) {
-                    if (allowed.has(entry)) {
-                        try {
-                            unlinkSync(join(rulesDir, entry));
-                        }
-                        catch { /* best-effort */ }
-                    }
-                }
-            }
-        }
-    }
-    // ── Usage stats (passive, best-effort) ─────────────────────────────
-    async readUsageStats(lastSyncAt) {
-        try {
-            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-            // Query composerData from state.vscdb (cursorDiskKV table)
-            const os = platform();
-            let globalDbPath;
-            if (os === 'darwin') {
-                globalDbPath = join(homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
-            }
-            else if (os === 'win32') {
-                globalDbPath = join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Cursor', 'User', 'globalStorage', 'state.vscdb');
-            }
-            else {
-                globalDbPath = join(homedir(), '.config', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
-            }
-            let sessionCount = 0;
-            let totalLinesAdded = 0;
-            let totalLinesRemoved = 0;
-            let latestActivity = 0;
-            let agenticSessions = 0;
-            let chatSessions = 0;
-            if (existsSync(globalDbPath)) {
-                const composerResult = querySqlite(globalDbPath, `SELECT value FROM cursorDiskKV WHERE key LIKE 'composerData-%'`);
-                if (composerResult) {
-                    for (const line of composerResult.split('\n')) {
-                        if (!line.trim())
-                            continue;
-                        try {
-                            const data = JSON.parse(line);
-                            const createdAt = data.createdAt ?? 0;
-                            if (createdAt > sinceMs) {
-                                sessionCount++;
-                                totalLinesAdded += data.totalLinesAdded ?? 0;
-                                totalLinesRemoved += data.totalLinesRemoved ?? 0;
-                                if (data.unifiedMode === 'agent' || data.isAgentic)
-                                    agenticSessions++;
-                                else
-                                    chatSessions++;
-                            }
-                            if (createdAt > latestActivity)
-                                latestActivity = createdAt;
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-            }
-            // Check scored_commits for AI contribution data
-            // ~/.cursor/ is consistent across platforms (unlike Application Support paths)
-            const trackingDbPath = join(homedir(), '.cursor', 'ai-tracking', 'ai-code-tracking.db');
-            let aiCommitCount = 0;
-            let avgAiPercent = 0;
-            if (existsSync(trackingDbPath)) {
-                const sinceSec = Math.floor(sinceMs / 1000);
-                const commitResult = querySqlite(trackingDbPath, `SELECT count(*), avg(CAST(v2AiPercentage AS REAL)) FROM scored_commits WHERE scoredAt > ${sinceSec}`);
-                if (commitResult) {
-                    const parts = commitResult.split('|');
-                    aiCommitCount = parseInt(parts[0]) || 0;
-                    avgAiPercent = parseFloat(parts[1]) || 0;
-                }
-            }
-            if (sessionCount === 0 && latestActivity <= sinceMs)
-                return null;
-            return {
-                hasNewActivity: sessionCount > 0,
-                sessionCount,
-                messageCount: 0,
-                toolCallCount: 0,
-                tokensUsed: 0,
-                aiLinesAdded: totalLinesAdded,
-                aiLinesRemoved: totalLinesRemoved,
-                lastActiveAt: latestActivity > 0 ? new Date(latestActivity).toISOString() : null,
-                extra: {
-                    agenticSessions,
-                    chatSessions,
-                    ...(aiCommitCount > 0 ? { aiCommitCount, avgAiContributionPercent: Math.round(avgAiPercent) } : {}),
-                },
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    async readVersion() {
-        try {
-            const output = execFileSync('cursor', ['--version'], { stdio: 'pipe' }).toString().trim();
-            return output;
-        }
-        catch {
-            return null;
-        }
-    }
-}

package/dist/agents/default-config.d.ts

@@ -1,30 +0,0 @@
-/**
- * Baked-in default permission rules that `runwork sync` injects into each
- * supported agent's configuration.
- *
- * Defaults are user-scope only. They merge with team-managed rules from the
- * workspace admin and are tracked in `~/.runwork/setup.json` under
- * `agentDefaults[slug]` so that:
- *   1. Removals stick: if a user deletes an injected entry, it never returns.
- *   2. Newly added defaults flow in: CLI upgrades that ship more defaults
- *      auto-apply on the next sync.
- *   3. Removed defaults disappear: shrinking the set here also removes the
- *      entries from users' on-disk config on next sync.
- *   4. Tool removal resets state: `runwork agents remove <slug>` clears the
- *      per-agent state, so re-adding the tool starts from a clean bootstrap.
- *
- * Only agents whose permission model maps cleanly to command-pattern allow/deny
- * lists appear here. Codex, Gemini, Cline, and Claude Desktop are intentionally
- * absent (their config formats are toggle-based or tool-name-based and do not
- * fit). Network domain allowlisting for those agents is handled separately via
- * AgentConfigOverride.networkAllowlist in sync.ts.
- */
-export interface BakedDefaults {
-    allow: string[];
-    deny: string[];
-}
-export declare const RUNWORK_AGENT_DEFAULTS: Record<string, BakedDefaults>;
-/** Schema version recorded in setup.json. Bump when default-injection semantics change. */
-export declare const AGENT_DEFAULTS_SCHEMA_VERSION = 1;
-/** Slugs that have baked-in defaults. */
-export declare function hasBakedDefaults(slug: string): boolean;