runwork 0.6.2 → 0.8.3

package/dist/agents/types.d.ts

@@ -29,16 +29,41 @@ export interface AgentAdapter {
     supportsSkills(): boolean;
     /** Whether this agent supports MCP config at the given scope */
     supportsMcpScope(scope: 'project' | 'user'): boolean;
+    /** True when this agent's skill files overlap with MCP skill_* tools (skip writing app skills when MCP is configured) */
+    mcpProvidesSkills?: boolean;
     /** Write team-managed instructions (separate marker block from auto-generated hint) */
     writeTeamInstructions?(instructions: string, scope: 'project' | 'user'): Promise<void>;
     /** Write agent-specific config overrides from workspace admin (model, permissions) */
     writeAgentConfig?(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
+    /** Remove all Runwork-managed config, skills, MCP entries, and instruction hints.
+     *  The manifest lists exactly which resources were synced so only those are removed. */
+    cleanup?(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
     /** Read passive usage stats from local agent files (best-effort, no hooks) */
     readUsageStats?(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
     /** Read which skills were used locally since last sync (best-effort) */
     readSkillUsage?(lastSyncAt: string | null): Promise<SkillUsageEntry[] | null>;
     /** Get the agent's version string (best-effort) */
     readVersion?(): Promise<string | null>;
+    /**
+     * Build an installable plugin archive for this agent. Implementations
+     * generate their agent-specific plugin layout into a temporary directory
+     * and zip it to `outputPath`. `teamInstructions` is the merged string of
+     * workspace team instructions + per-agent extra instructions (or null if
+     * none are configured) — adapters should embed them in the archive so
+     * uploaded zips match what a normal sync would write. Only adapters whose
+     * target agent has a plugin upload flow implement this (e.g. Claude Desktop).
+     */
+    buildPluginZip?(skills: SkillFile[], mcpServers: McpServerEntry[], teamInstructions: string | null, outputPath: string): Promise<void>;
+}
+/**
+ * Exact list of resources that Runwork synced to this agent.
+ * Cleanup must only remove these specific items, nothing else.
+ */
+export interface CleanupManifest {
+    /** Skill directory/file names that were written (kebab-case slugs) */
+    skillFilenames: string[];
+    /** MCP server entry names that were registered */
+    mcpServerNames: string[];
 }
 export interface AgentConfigOverride {
     extraInstructions?: string;
@@ -48,6 +73,8 @@ export interface AgentConfigOverride {
         deny?: string[];
         defaultMode?: string;
     };
+    /** Domains to allowlist in the agent's sandbox/network config (e.g. for Cursor CLI sandbox) */
+    networkAllowlist?: string[];
 }
 export interface AgentUsageStats {
     hasNewActivity: boolean;
@@ -72,7 +99,20 @@ export declare const RUNWORK_MCP_PREFIX = "Runwork: ";
 /** Legacy prefix used before human-readable names were introduced */
 export declare const RUNWORK_MCP_PREFIX_LEGACY = "runwork-";
 /**
- * Build a SKILL.md file with YAML frontmatter.
- * Ensures the content always has proper frontmatter for agent discovery.
+ * Top-level name for the Runwork workspace tools MCP server.
+ * Kept short (no prefix) so agents surface tools as `mcp__Runwork__*`
+ * instead of the visually noisy `mcp__Runwork_Workspace_Tools__*`.
+ */
+export declare const RUNWORK_WORKSPACE_MCP_NAME = "Runwork";
+/**
+ * Append an auth token to a URL as a query parameter.
+ * The server extracts this via its standard token extraction (query param fallback).
+ */
+export declare function appendTokenToUrl(url: string, token: string): string;
+/**
+ * Convert a skill display name to a kebab-case slug safe for slash commands.
+ * Spaces in skill names break slash command parsing (e.g. "/Write Cold Email"
+ * gets parsed as skill "Write" with args "Cold Email").
  */
+export declare function toSlug(name: string): string;
 export declare function buildSkillMd(skill: SkillFile): string;

package/dist/agents/types.js

@@ -2,19 +2,74 @@
 export const RUNWORK_MCP_PREFIX = 'Runwork: ';
 /** Legacy prefix used before human-readable names were introduced */
 export const RUNWORK_MCP_PREFIX_LEGACY = 'runwork-';
+/**
+ * Top-level name for the Runwork workspace tools MCP server.
+ * Kept short (no prefix) so agents surface tools as `mcp__Runwork__*`
+ * instead of the visually noisy `mcp__Runwork_Workspace_Tools__*`.
+ */
+export const RUNWORK_WORKSPACE_MCP_NAME = 'Runwork';
+/**
+ * Append an auth token to a URL as a query parameter.
+ * The server extracts this via its standard token extraction (query param fallback).
+ */
+export function appendTokenToUrl(url, token) {
+    const parsed = new URL(url);
+    parsed.searchParams.set('token', token);
+    return parsed.toString();
+}
+/**
+ * Convert a skill display name to a kebab-case slug safe for slash commands.
+ * Spaces in skill names break slash command parsing (e.g. "/Write Cold Email"
+ * gets parsed as skill "Write" with args "Cold Email").
+ */
+export function toSlug(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
 /**
  * Build a SKILL.md file with YAML frontmatter.
  * Ensures the content always has proper frontmatter for agent discovery.
+ * The name field is always kebab-cased to work as a slash command.
+ */
+/**
+ * Quote a YAML value if it contains characters that would break parsing
+ * (colons, brackets, quotes, leading/trailing spaces, etc.)
  */
+function yamlQuote(value) {
+    if (/[:#\[\]{}|>&*!,?'"]/.test(value) || value !== value.trim()) {
+        // Use double quotes, escaping internal double quotes and backslashes
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        return `"${escaped}"`;
+    }
+    return value;
+}
 export function buildSkillMd(skill) {
     const description = skill.description || `${skill.name} skill`;
-    // If content already has frontmatter, ensure description is present
+    const slug = toSlug(skill.name);
+    const safeDescription = yamlQuote(description);
     if (skill.content.trimStart().startsWith('---\n')) {
-        const hasDescription = /^description:\s*.+$/m.test(skill.content);
+        let content = skill.content;
+        // Normalize name to kebab-case slug (spaces break slash command parsing)
+        content = content.replace(/^(name:\s*)["']?[^"'\n]+["']?\s*$/m, `$1${slug}`);
+        // Normalize description: ensure space after colon, strip nested quotes, and quote if needed
+        content = content.replace(/^description:\s*(.+)$/m, (_match, rawValue) => {
+            // Strip wrapping quotes and escaped quotes from the raw value
+            let cleaned = rawValue.trim();
+            // Remove outer quotes if present (single or double)
+            if ((cleaned.startsWith('"') && cleaned.endsWith('"')) || (cleaned.startsWith("'") && cleaned.endsWith("'"))) {
+                cleaned = cleaned.slice(1, -1);
+            }
+            // Remove escaped quotes left from double-wrapping (e.g. \"value\")
+            cleaned = cleaned.replace(/\\"/g, '"');
+            // Strip any remaining wrapping quotes after unescaping
+            if ((cleaned.startsWith('"') && cleaned.endsWith('"')) || (cleaned.startsWith("'") && cleaned.endsWith("'"))) {
+                cleaned = cleaned.slice(1, -1);
+            }
+            return `description: ${yamlQuote(cleaned)}`;
+        });
+        const hasDescription = /^description:\s*.+$/m.test(content);
         if (hasDescription)
-            return skill.content;
-        // Inject description into existing frontmatter
-        return skill.content.replace(/^---\n/, `---\nname: ${skill.name}\ndescription: ${description}\n`);
+            return content;
+        return content.replace(/^---\n/, `---\nname: ${slug}\ndescription: ${safeDescription}\n`);
     }
-    return `---\nname: ${skill.name}\ndescription: ${description}\n---\n\n${skill.content}`;
+    return `---\nname: ${slug}\ndescription: ${safeDescription}\n---\n\n${skill.content}`;
 }

package/dist/agents/utils/instruction-hint.d.ts

@@ -8,4 +8,14 @@ export declare function writeHintToFile(filePath: string, hint: string): void;
  * Append or replace team instructions in an agent's instruction file.
  * Uses separate markers from the auto-generated hint so both coexist.
  */
+/**
+ * Remove the Runwork instruction hint from an agent's instruction file.
+ * Returns true if something was removed.
+ */
+export declare function removeHintFromFile(filePath: string): boolean;
+/**
+ * Remove Runwork team instructions from an agent's instruction file.
+ * Returns true if something was removed.
+ */
+export declare function removeTeamInstructionsFromFile(filePath: string): boolean;
 export declare function writeTeamInstructionsToFile(filePath: string, instructions: string): void;

package/dist/agents/utils/instruction-hint.js

@@ -37,6 +37,52 @@ export function writeHintToFile(filePath, hint) {
  * Append or replace team instructions in an agent's instruction file.
  * Uses separate markers from the auto-generated hint so both coexist.
  */
+/**
+ * Remove the Runwork instruction hint from an agent's instruction file.
+ * Returns true if something was removed.
+ */
+export function removeHintFromFile(filePath) {
+    if (!existsSync(filePath))
+        return false;
+    let content = readFileSync(filePath, 'utf-8');
+    const startIdx = content.indexOf(START_MARKER);
+    const endIdx = content.indexOf(END_MARKER);
+    if (startIdx < 0 || endIdx < 0)
+        return false;
+    content = content.substring(0, startIdx) + content.substring(endIdx + END_MARKER.length);
+    // Clean up extra blank lines left behind
+    content = content.replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+    if (content.trim() === '') {
+        // File is now empty, could remove it but safer to leave a minimal file
+        writeFileSync(filePath, '');
+    }
+    else {
+        writeFileSync(filePath, content);
+    }
+    return true;
+}
+/**
+ * Remove Runwork team instructions from an agent's instruction file.
+ * Returns true if something was removed.
+ */
+export function removeTeamInstructionsFromFile(filePath) {
+    if (!existsSync(filePath))
+        return false;
+    let content = readFileSync(filePath, 'utf-8');
+    const startIdx = content.indexOf(TEAM_START_MARKER);
+    const endIdx = content.indexOf(TEAM_END_MARKER);
+    if (startIdx < 0 || endIdx < 0)
+        return false;
+    content = content.substring(0, startIdx) + content.substring(endIdx + TEAM_END_MARKER.length);
+    content = content.replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+    if (content.trim() === '') {
+        writeFileSync(filePath, '');
+    }
+    else {
+        writeFileSync(filePath, content);
+    }
+    return true;
+}
 export function writeTeamInstructionsToFile(filePath, instructions) {
     mkdirSync(dirname(filePath), { recursive: true });
     let content = '';

package/dist/agents/utils/json-config.d.ts

@@ -6,9 +6,14 @@ export declare function readJsonConfig(filePath: string): Record<string, unknown
  * Write a JSON config file, creating parent directories as needed.
  */
 export declare function writeJsonConfig(filePath: string, config: Record<string, unknown>): void;
+/**
+ * Remove all Runwork-managed MCP server entries from a JSON config file.
+ * Returns true if any entries were removed.
+ */
+export declare function removeRunworkMcpServers(filePath: string, topKey: string): boolean;
 /**
  * Merge MCP server entries into a JSON config file.
- * Removes all existing runwork-* entries, adds new ones.
+ * Removes all existing runwork-managed entries, adds new ones.
  * Preserves user's non-runwork entries.
  */
 export declare function mergeJsonMcpServers(filePath: string, servers: Record<string, Record<string, unknown>>, topKey: string): void;

package/dist/agents/utils/json-config.js

@@ -1,6 +1,11 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { dirname } from 'path';
-import { RUNWORK_MCP_PREFIX, RUNWORK_MCP_PREFIX_LEGACY } from '../types.js';
+import { RUNWORK_MCP_PREFIX, RUNWORK_MCP_PREFIX_LEGACY, RUNWORK_WORKSPACE_MCP_NAME, } from '../types.js';
+function isRunworkManagedKey(key) {
+    return (key === RUNWORK_WORKSPACE_MCP_NAME ||
+        key.startsWith(RUNWORK_MCP_PREFIX) ||
+        key.startsWith(RUNWORK_MCP_PREFIX_LEGACY));
+}
 /**
  * Read a JSON config file. Returns empty object if file doesn't exist.
  */
@@ -21,17 +26,39 @@ export function writeJsonConfig(filePath, config) {
     mkdirSync(dirname(filePath), { recursive: true });
     writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
 }
+/**
+ * Remove all Runwork-managed MCP server entries from a JSON config file.
+ * Returns true if any entries were removed.
+ */
+export function removeRunworkMcpServers(filePath, topKey) {
+    if (!existsSync(filePath))
+        return false;
+    const config = readJsonConfig(filePath);
+    const existing = (config[topKey] || {});
+    let removed = false;
+    for (const key of Object.keys(existing)) {
+        if (isRunworkManagedKey(key)) {
+            delete existing[key];
+            removed = true;
+        }
+    }
+    if (removed) {
+        config[topKey] = existing;
+        writeJsonConfig(filePath, config);
+    }
+    return removed;
+}
 /**
  * Merge MCP server entries into a JSON config file.
- * Removes all existing runwork-* entries, adds new ones.
+ * Removes all existing runwork-managed entries, adds new ones.
  * Preserves user's non-runwork entries.
  */
 export function mergeJsonMcpServers(filePath, servers, topKey) {
     const config = readJsonConfig(filePath);
     const existing = (config[topKey] || {});
-    // Remove all Runwork-managed entries (current and legacy prefixes)
+    // Remove all Runwork-managed entries (current, legacy, and the bare "Runwork" name)
     for (const key of Object.keys(existing)) {
-        if (key.startsWith(RUNWORK_MCP_PREFIX) || key.startsWith(RUNWORK_MCP_PREFIX_LEGACY)) {
+        if (isRunworkManagedKey(key)) {
             delete existing[key];
         }
     }

package/dist/agents/windsurf.d.ts

@@ -1,7 +1,8 @@
-import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+import type { AgentAdapter, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
 export declare class WindsurfAdapter implements AgentAdapter {
     name: string;
     slug: string;
+    mcpProvidesSkills: boolean;
     detect(): Promise<boolean>;
     supportsMcpScope(scope: 'project' | 'user'): boolean;
     supportsSkills(): boolean;
@@ -9,4 +10,5 @@ export declare class WindsurfAdapter implements AgentAdapter {
     writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
     writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
     writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
+    cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
 }

package/dist/agents/windsurf.js

@@ -1,8 +1,8 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir, platform } from 'os';
 import { whichBinary } from '../utils/which.js';
-import { mergeJsonMcpServers } from './utils/json-config.js';
+import { mergeJsonMcpServers, removeRunworkMcpServers } from './utils/json-config.js';
 function getWindsurfDataDir() {
     if (platform() === 'win32') {
         return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Codeium', 'windsurf');
@@ -15,6 +15,7 @@ function getConfigPath() {
 export class WindsurfAdapter {
     name = 'Windsurf';
     slug = 'windsurf';
+    mcpProvidesSkills = true;
     async detect() {
         const os = platform();
         if (os === 'darwin' && existsSync('/Applications/Windsurf.app'))
@@ -64,4 +65,38 @@ export class WindsurfAdapter {
         mkdirSync(join(filePath, '..'), { recursive: true });
         writeFileSync(filePath, content);
     }
+    // ── Cleanup (uninstall) ────────────────────────────────────────────
+    async cleanup(scope, manifest) {
+        // 1. Remove MCP entries (user scope only)
+        if (scope === 'user') {
+            removeRunworkMcpServers(getConfigPath(), 'mcpServers');
+        }
+        // 2. Remove rule files
+        const rulesDir = scope === 'project'
+            ? join(process.cwd(), '.windsurf', 'rules')
+            : join(getWindsurfDataDir(), 'rules');
+        if (existsSync(rulesDir)) {
+            for (const file of ['runwork.md', 'runwork-team.md']) {
+                const filePath = join(rulesDir, file);
+                if (existsSync(filePath)) {
+                    try {
+                        unlinkSync(filePath);
+                    }
+                    catch { /* best-effort */ }
+                }
+            }
+            // Remove only skill .md files that we synced
+            if (manifest?.skillFilenames.length) {
+                const allowed = new Set(manifest.skillFilenames.map(f => `${f}.md`));
+                for (const entry of readdirSync(rulesDir)) {
+                    if (allowed.has(entry)) {
+                        try {
+                            unlinkSync(join(rulesDir, entry));
+                        }
+                        catch { /* best-effort */ }
+                    }
+                }
+            }
+        }
+    }
 }

package/dist/commands/__tests__/sync-telemetry.test.d.ts

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

package/dist/commands/__tests__/sync-telemetry.test.js

@@ -0,0 +1,281 @@
+import { describe, it, expect } from 'vitest';
+import { collectTelemetryEvents, summarizeTelemetryForDryRun } from '../sync-telemetry.js';
+function mockAdapter(slug, opts = {}) {
+    return {
+        slug,
+        name: slug,
+        detect: async () => true,
+        supportsSkills: () => false,
+        supportsMcpScope: () => false,
+        writeSkills: async () => { },
+        writeMcpServers: async () => { },
+        writeInstructionHint: async () => { },
+        ...opts,
+    };
+}
+function baseState(overrides = {}) {
+    return {
+        workspaceId: 'ws-1',
+        workspaceName: 'Test',
+        configuredAgents: [],
+        scope: 'user',
+        lastSyncAt: '2026-04-13T00:00:00.000Z',
+        mcpServers: [],
+        skills: [],
+        ...overrides,
+    };
+}
+const NOW = '2026-04-14T00:00:00.000Z';
+describe('collectTelemetryEvents', () => {
+    it('always emits a sync_completed event with aggregate counts', async () => {
+        const result = await collectTelemetryEvents({
+            adapters: [],
+            state: baseState(),
+            syncedSkillsCount: 5,
+            syncedMcpServersCount: 2,
+            teamInstructionsApplied: true,
+            agentConfigsApplied: 1,
+            now: NOW,
+        });
+        const syncCompleted = result.events.find(e => e.eventType === 'local_agent.sync_completed');
+        expect(syncCompleted).toBeDefined();
+        expect(syncCompleted?.metadata).toMatchObject({
+            syncedSkills: 5,
+            syncedMcpServers: 2,
+            teamInstructionsApplied: true,
+            agentConfigsApplied: 1,
+        });
+    });
+    it('emits local_agent.detected only for newly seen agents', async () => {
+        const result = await collectTelemetryEvents({
+            adapters: [],
+            state: baseState({
+                configuredAgents: ['claude-code', 'cursor', 'codex'],
+                reportedAgentSlugs: ['claude-code'],
+            }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        const detectedSlugs = result.events
+            .filter(e => e.eventType === 'local_agent.detected')
+            .map(e => e.agentSlug);
+        expect(detectedSlugs).toEqual(['cursor', 'codex']);
+        expect(result.newlyReportedAgents).toEqual(['cursor', 'codex']);
+    });
+    it('emits local_agent.usage when adapter reports hasNewActivity', async () => {
+        const stats = {
+            hasNewActivity: true,
+            sessionCount: 3,
+            messageCount: 42,
+            toolCallCount: 10,
+            tokensUsed: 1000,
+            aiLinesAdded: 50,
+            aiLinesRemoved: 10,
+            lastActiveAt: '2026-04-13T23:00:00.000Z',
+            modelsUsed: ['sonnet'],
+            mcpToolCount: 5,
+            extra: { customField: 'value' },
+        };
+        const adapter = mockAdapter('claude-code', {
+            readUsageStats: async () => stats,
+        });
+        const result = await collectTelemetryEvents({
+            adapters: [adapter],
+            state: baseState({ configuredAgents: ['claude-code'], reportedAgentSlugs: ['claude-code'] }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        const usage = result.events.find(e => e.eventType === 'local_agent.usage');
+        expect(usage).toBeDefined();
+        expect(usage?.agentSlug).toBe('claude-code');
+        expect(usage?.metadata).toMatchObject({
+            sessionCount: 3,
+            messageCount: 42,
+            tokensUsed: 1000,
+            mcpToolCount: 5,
+            customField: 'value',
+        });
+        expect(result.adapterResults[0].stats).toEqual(stats);
+    });
+    it('does not emit usage event when hasNewActivity is false', async () => {
+        const adapter = mockAdapter('cursor', {
+            readUsageStats: async () => ({
+                hasNewActivity: false,
+                sessionCount: 0,
+                messageCount: 0,
+                toolCallCount: 0,
+                tokensUsed: 0,
+                aiLinesAdded: 0,
+                aiLinesRemoved: 0,
+                lastActiveAt: null,
+            }),
+        });
+        const result = await collectTelemetryEvents({
+            adapters: [adapter],
+            state: baseState({ configuredAgents: ['cursor'], reportedAgentSlugs: ['cursor'] }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        expect(result.events.find(e => e.eventType === 'local_agent.usage')).toBeUndefined();
+        expect(result.adapterResults[0].stats).toBeTruthy();
+    });
+    it('marks stats and skills as unsupported when adapter lacks readers', async () => {
+        const adapter = mockAdapter('cline');
+        const result = await collectTelemetryEvents({
+            adapters: [adapter],
+            state: baseState({ configuredAgents: ['cline'], reportedAgentSlugs: ['cline'] }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        expect(result.adapterResults[0].stats).toBe('unsupported');
+        expect(result.adapterResults[0].skills).toBe('unsupported');
+    });
+    it('captures errors thrown by readUsageStats without failing overall collection', async () => {
+        const good = mockAdapter('codex', {
+            readUsageStats: async () => ({
+                hasNewActivity: true,
+                sessionCount: 1,
+                messageCount: 0,
+                toolCallCount: 0,
+                tokensUsed: 100,
+                aiLinesAdded: 0,
+                aiLinesRemoved: 0,
+                lastActiveAt: NOW,
+            }),
+        });
+        const broken = mockAdapter('cursor', {
+            readUsageStats: async () => {
+                throw new Error('db locked');
+            },
+        });
+        const result = await collectTelemetryEvents({
+            adapters: [broken, good],
+            state: baseState({
+                configuredAgents: ['cursor', 'codex'],
+                reportedAgentSlugs: ['cursor', 'codex'],
+            }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        const brokenResult = result.adapterResults.find(r => r.slug === 'cursor');
+        expect(brokenResult?.error).toContain('db locked');
+        expect(brokenResult?.stats).toBeNull();
+        const goodResult = result.adapterResults.find(r => r.slug === 'codex');
+        expect(goodResult?.error).toBeUndefined();
+        expect(result.events
+            .filter(e => e.eventType === 'local_agent.usage')
+            .map(e => e.agentSlug)).toEqual(['codex']);
+    });
+    it('emits one skill_used event per skill entry', async () => {
+        const entries = [
+            { skillName: 'runwork', count: 1, lastUsedAt: '2026-04-13T12:00:00.000Z' },
+            { skillName: 'seo-content-strategist', count: 2, lastUsedAt: '2026-04-13T13:00:00.000Z' },
+        ];
+        const adapter = mockAdapter('claude-code', {
+            readSkillUsage: async () => entries,
+        });
+        const result = await collectTelemetryEvents({
+            adapters: [adapter],
+            state: baseState({ configuredAgents: ['claude-code'], reportedAgentSlugs: ['claude-code'] }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        const skillEvents = result.events.filter(e => e.eventType === 'local_agent.skill_used');
+        expect(skillEvents).toHaveLength(2);
+        expect(skillEvents[0].metadata?.skillName).toBe('runwork');
+        expect(skillEvents[1].metadata?.skillName).toBe('seo-content-strategist');
+    });
+    it('reports health when lastHealthReportAt is missing', async () => {
+        const adapter = mockAdapter('codex', {
+            readVersion: async () => '0.5.0',
+        });
+        const result = await collectTelemetryEvents({
+            adapters: [adapter],
+            state: baseState({ configuredAgents: ['codex'], reportedAgentSlugs: ['codex'] }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        expect(result.healthReported).toBe(true);
+        const health = result.events.find(e => e.eventType === 'local_agent.health');
+        expect(health?.metadata?.version).toBe('0.5.0');
+        expect(health?.metadata?.installed).toBe(true);
+    });
+    it('skips health when last reported less than 24h ago', async () => {
+        const recent = new Date(Date.now() - 60 * 60 * 1000).toISOString();
+        const adapter = mockAdapter('codex', {
+            readVersion: async () => '0.5.0',
+        });
+        const result = await collectTelemetryEvents({
+            adapters: [adapter],
+            state: baseState({
+                configuredAgents: ['codex'],
+                reportedAgentSlugs: ['codex'],
+                lastHealthReportAt: recent,
+            }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        expect(result.healthReported).toBe(false);
+        expect(result.events.find(e => e.eventType === 'local_agent.health')).toBeUndefined();
+    });
+});
+describe('summarizeTelemetryForDryRun', () => {
+    it('counts adapters with active stats', async () => {
+        const result = await collectTelemetryEvents({
+            adapters: [
+                mockAdapter('codex', {
+                    readUsageStats: async () => ({
+                        hasNewActivity: true,
+                        sessionCount: 1,
+                        messageCount: 0,
+                        toolCallCount: 0,
+                        tokensUsed: 0,
+                        aiLinesAdded: 0,
+                        aiLinesRemoved: 0,
+                        lastActiveAt: NOW,
+                    }),
+                }),
+                mockAdapter('cursor', {
+                    readUsageStats: async () => null,
+                }),
+                mockAdapter('cline'),
+            ],
+            state: baseState({
+                configuredAgents: ['codex', 'cursor', 'cline'],
+                reportedAgentSlugs: ['codex', 'cursor', 'cline'],
+            }),
+            syncedSkillsCount: 0,
+            syncedMcpServersCount: 0,
+            teamInstructionsApplied: false,
+            agentConfigsApplied: 0,
+            now: NOW,
+        });
+        const summary = summarizeTelemetryForDryRun(result);
+        expect(summary).toContain('1 adapter with activity');
+        expect(summary).toContain('events would be sent');
+    });
+});

package/dist/commands/__tests__/upgrade.test.d.ts

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