runwork 0.12.0 → 0.13.1

package/dist/commands/sync.js

@@ -11,6 +11,7 @@ import { RUNWORK_AGENT_DEFAULTS, AGENT_DEFAULTS_SCHEMA_VERSION } from '../agents
 import { resolveAgentDefaults } from '../agents/defaults-merge.js';
 import { collectTelemetryEvents, printTelemetryVerbose, summarizeTelemetryForDryRun, } from './sync-telemetry.js';
 import { generateIntroSkill, generateInstructionHint, buildAppSkillDescription } from '../agents/intro-skill.js';
+import { buildShareConversationSkill, buildSaveConversationSkill, BUILT_IN_SKILL_NAMES } from '../agents/conversation-skills.js';
 import { computeSyncPlan } from '../sync/change-detect.js';
 import { printSyncSummary, resolveConflict, resolveConflictNonInteractive } from '../sync/conflict-ui.js';
 import { executeSyncPlan } from '../sync/executor.js';
@@ -194,11 +195,27 @@ export async function syncFromState(state, statePath, credentials, opts) {
     }
     // Read local skills for change detection
     const localSkills = readLocalSkills(state);
+    // Built-in skills (shipped by the CLI from code) are CANONICAL: they
+    // are never pushed to the workspace and never pulled from it. The diff
+    // engine must not see them at all -- if it did, a workspace skill that
+    // happens to share a name (e.g. someone uploaded `share-conversation`
+    // manually) would either push the built-in upstream or pull the stale
+    // workspace copy on top, both wrong. Filter both sides before the diff.
+    const builtInNameSet = new Set(BUILT_IN_SKILL_NAMES);
+    const collidingRemote = remoteSkills.filter(s => builtInNameSet.has(s.name));
+    if (collidingRemote.length > 0) {
+        console.log(`\n  Warning: ${collidingRemote.length} workspace skill${collidingRemote.length === 1 ? '' : 's'} ` +
+            `shadow${collidingRemote.length === 1 ? 's' : ''} built-in CLI skill${collidingRemote.length === 1 ? '' : 's'}: ` +
+            `${collidingRemote.map(s => s.name).join(', ')}. The CLI built-in versions will be used locally; ` +
+            `the workspace copies are stale duplicates and can be safely deleted from the dashboard.`);
+    }
+    const localSkillsForDiff = localSkills.filter(s => !builtInNameSet.has(s.name));
+    const remoteSkillsForDiff = remoteSkills.filter(s => !builtInNameSet.has(s.name));
     // Compute sync plan
     const plan = computeSyncPlan({
         storedHashes: state.skillHashes || {},
-        localSkills,
-        remoteSkills,
+        localSkills: localSkillsForDiff,
+        remoteSkills: remoteSkillsForDiff,
     });
     // In pull-only mode, move pushes and conflicts to skips
     if (opts.pullOnly) {
@@ -306,7 +323,28 @@ export async function syncFromState(state, statePath, credentials, opts) {
         }
         catch { /* ignore */ }
     }
+    // Built-in skills shipped by the CLI on every sync. Named upfront so we can
+    // surface them by name in the per-adapter sync log -- helps users (and
+    // their agents) confirm that /runwork, /share-conversation, etc. landed.
+    const builtInSkills = [
+        introSkill,
+        buildShareConversationSkill(),
+        buildSaveConversationSkill(),
+    ];
+    const builtInNames = builtInSkills.map(s => s.name);
+    // Counters surfaced at the end of the sync as a one-line summary so the
+    // user can see at a glance how much actually got written this run.
+    const summary = {
+        adaptersProcessed: 0,
+        adaptersFailed: 0,
+        skillWrites: 0,
+        skillFilesWritten: 0,
+        mcpServerWrites: 0,
+        instructionHintWrites: 0,
+        hookInstallCalls: 0,
+    };
     for (const adapter of adapters) {
+        let adapterFailedAnyScope = false;
         for (const scope of scopes) {
             try {
                 // Write skills: for project scope, filter to only the current app's skill.
@@ -316,6 +354,11 @@ export async function syncFromState(state, statePath, credentials, opts) {
                 if (adapter.supportsSkills()) {
                     const skipAppSkills = adapter.mcpProvidesSkills && mcpEntries.length > 0;
                     const scopeSkills = remoteSkills.filter(s => {
+                        // Built-in CLI skills are written from the canonical built-in array
+                        // below; a workspace skill with the same name is a shadow that
+                        // would overwrite the built-in if we let it through. Skip it.
+                        if (builtInNameSet.has(s.name))
+                            return false;
                         // App-sourced skills are already available via MCP skill_* tools
                         if (skipAppSkills && s.source === 'app')
                             return false;
@@ -325,29 +368,57 @@ export async function syncFromState(state, statePath, credentials, opts) {
                         }
                         return true;
                     });
-                    const allSkillFiles = [introSkill, ...scopeSkills.map(s => ({
-                            name: s.name,
-                            filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
-                            content: s.content,
-                            description: s.source === 'app'
-                                ? (buildAppSkillDescription(s.name, registries) || `${s.name} - Runwork workspace application`)
-                                : `${s.name} - Runwork workspace skill`,
-                        }))];
+                    const workspaceSkillFiles = scopeSkills.map(s => ({
+                        name: s.name,
+                        filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+                        content: s.content,
+                        description: s.source === 'app'
+                            ? (buildAppSkillDescription(s.name, registries) || `${s.name} - Runwork workspace application`)
+                            : `${s.name} - Runwork workspace skill`,
+                    }));
+                    const allSkillFiles = [...builtInSkills, ...workspaceSkillFiles];
                     await adapter.writeSkills(allSkillFiles, scope);
+                    summary.skillWrites++;
+                    summary.skillFilesWritten += allSkillFiles.length;
+                    console.log(`  [${adapter.name}] Wrote ${allSkillFiles.length} skills (${scope}): ` +
+                        `${builtInSkills.length} built-in [${builtInNames.join(', ')}], ` +
+                        `${workspaceSkillFiles.length} workspace`);
+                }
+                else {
+                    console.log(`  [${adapter.name}] Skipped skills (${scope}): adapter does not support skills`);
                 }
                 // Write MCP configs
                 if (adapter.supportsMcpScope(scope) && mcpEntries.length > 0) {
                     await adapter.writeMcpServers(mcpEntries, scope);
+                    summary.mcpServerWrites++;
                     console.log(`  [${adapter.name}] Updated ${mcpEntries.length} MCP server${mcpEntries.length > 1 ? 's' : ''} (${scope})`);
                 }
+                else if (mcpEntries.length === 0) {
+                    console.log(`  [${adapter.name}] Skipped MCP servers (${scope}): no workspace MCP servers configured`);
+                }
+                else if (!adapter.supportsMcpScope(scope)) {
+                    console.log(`  [${adapter.name}] Skipped MCP servers (${scope}): adapter does not support MCP at this scope`);
+                }
                 // Write instruction hint
                 await adapter.writeInstructionHint(instructionHint, scope);
+                summary.instructionHintWrites++;
                 console.log(`  [${adapter.name}] Updated instruction hints (${scope})`);
+                // Install built-in hooks (Claude Code's SessionStart, etc.). Called
+                // after writeSkills so the plugin tree already exists. Skipped by
+                // adapters that don't implement it.
+                if (adapter.writeBuiltInHooks) {
+                    await adapter.writeBuiltInHooks(scope);
+                    summary.hookInstallCalls++;
+                }
             }
             catch (err) {
+                adapterFailedAnyScope = true;
                 console.warn(`  [${adapter.name}] Failed (${scope}): ${err instanceof Error ? err.message : err}`);
             }
         }
+        summary.adaptersProcessed++;
+        if (adapterFailedAnyScope)
+            summary.adaptersFailed++;
     }
     // Pull team config from server. A failure here must not stop the
     // unified user-scope write below, which applies network and minimum-permission
@@ -569,6 +640,20 @@ export async function syncFromState(state, statePath, credentials, opts) {
     catch {
         // Telemetry failures are non-fatal
     }
+    // One-line summary so the user (and any agent reading sync output) can
+    // see at a glance what got written this run, without scrolling the whole
+    // per-adapter log.
+    const summaryParts = [];
+    summaryParts.push(`${summary.adaptersProcessed} adapter${summary.adaptersProcessed === 1 ? '' : 's'}`);
+    if (summary.adaptersFailed > 0)
+        summaryParts.push(`${summary.adaptersFailed} failed`);
+    summaryParts.push(`${summary.skillWrites} skill write${summary.skillWrites === 1 ? '' : 's'} (${summary.skillFilesWritten} files)`);
+    if (summary.mcpServerWrites > 0)
+        summaryParts.push(`${summary.mcpServerWrites} MCP config write${summary.mcpServerWrites === 1 ? '' : 's'}`);
+    if (summary.hookInstallCalls > 0)
+        summaryParts.push(`${summary.hookInstallCalls} hook install${summary.hookInstallCalls === 1 ? '' : 's'}`);
+    summaryParts.push(`${summary.instructionHintWrites} instruction hint write${summary.instructionHintWrites === 1 ? '' : 's'}`);
+    console.log(`\n  Summary: ${summaryParts.join(', ')}.`);
 }
 export const syncCommand = new Command('sync')
     .description('Sync skills bidirectionally and refresh MCP configs from workspace')

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.12.0";
+export declare const VERSION = "0.13.1";

package/dist/generated/version.js

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

package/dist/index.js

@@ -27,6 +27,10 @@ import { buildPluginCommand } from './commands/build-plugin.js';
 import { uninstallCommand } from './commands/uninstall.js';
 import { appsCommand } from './commands/apps.js';
 import { doctorCommand } from './commands/doctor.js';
+import { shareConvoCommand } from './commands/share-convo.js';
+import { saveConvoCommand } from './commands/save-convo.js';
+import { inboxCommand } from './commands/inbox.js';
+import { resumeCommand } from './commands/resume.js';
 import { handleGitCredentialRequest } from './git/credentials.js';
 import { VERSION } from './generated/version.js';
 import { shouldOutputJson, jsonOut } from './utils/output.js';
@@ -79,6 +83,10 @@ program.addCommand(buildPluginCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(appsCommand);
 program.addCommand(doctorCommand);
+program.addCommand(shareConvoCommand);
+program.addCommand(saveConvoCommand);
+program.addCommand(inboxCommand);
+program.addCommand(resumeCommand);
 program.addHelpText('after', '\nFor AI agents: run "runwork info --json" to discover app context and available commands.');
 // JSON help: intercept --help when --json is active or stdout is not a TTY.
 // Outputs the full command tree as structured JSON for AI agents.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runwork",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "CLI for Runwork: develop, preview, and deploy Runwork apps from your local machine.",
   "license": "UNLICENSED",
   "author": "Runwork <info@runwork.ai> (https://www.runwork.ai)",