runwork 0.11.0 → 0.13.1

package/dist/commands/setup.d.ts

@@ -1,5 +1,12 @@
 import { Command } from 'commander';
 import { ApiClient } from '../api/client.js';
+import type { SetupState } from '../types.js';
+/**
+ * Resolve the persona to persist in setup.json. Prefers the `--persona` flag
+ * (passed by the desktop onboarding flow); otherwise preserves any persona
+ * already on disk so re-running `setup` without the flag does not wipe it.
+ */
+export declare function resolvePersona(flag: string | undefined, existing: SetupState['persona']): SetupState['persona'];
 /**
  * Resolve the workspace for `setup` and persist it as the default in credentials.
  *

package/dist/commands/setup.js

@@ -8,6 +8,26 @@ import { resolveWorkspace, hasProjectConfig } from '../workspace/resolve.js';
 import { promptSelect, promptConfirm } from '../utils/prompt.js';
 import { detectAgents, printNoAgentsMessage } from '../agents/detect.js';
 import { syncFromState } from './sync.js';
+import { loadSetupState } from '../utils/setup-state.js';
+const PERSONA_LABELS = {
+    1: 'novice',
+    2: 'curious',
+    3: 'engineer',
+};
+/**
+ * Resolve the persona to persist in setup.json. Prefers the `--persona` flag
+ * (passed by the desktop onboarding flow); otherwise preserves any persona
+ * already on disk so re-running `setup` without the flag does not wipe it.
+ */
+export function resolvePersona(flag, existing) {
+    if (flag) {
+        const level = Number(flag);
+        if (level === 1 || level === 2 || level === 3) {
+            return { level, label: PERSONA_LABELS[level] };
+        }
+    }
+    return existing;
+}
 /**
  * Resolve the workspace for `setup` and persist it as the default in credentials.
  *
@@ -49,6 +69,7 @@ export const setupCommand = new Command('setup')
     .option('--agent <slug>', 'Only configure a specific agent (e.g. claude-code, cursor)')
     .option('--dry-run', 'Show what would be configured without writing files')
     .option('-y, --yes', 'Skip all prompts, configure all detected agents with user scope')
+    .option('--persona <level>', 'Technical-level persona for agent instructions (1=novice, 2=curious, 3=engineer)')
     .action(async (opts) => {
     const credentials = requireAuth();
     const client = new ApiClient(credentials);
@@ -124,6 +145,7 @@ export const setupCommand = new Command('setup')
         skills: [],
         skillHashes: {},
         lastDetectedAt: new Date().toISOString(),
+        persona: resolvePersona(opts.persona, loadSetupState()?.persona),
     };
     const scopes = scope === 'both' ? ['project', 'user'] : [scope];
     for (const s of scopes) {

package/dist/commands/share-convo.d.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+/**
+ * `runwork share-convo` - share the current AI conversation with a teammate.
+ *
+ * Typically invoked by the `share-conversation` skill from inside an AI agent.
+ * The skill is responsible for emitting the markdown transcript and metadata;
+ * this command does the upload, host-agent detection, and native-bundle pickup.
+ */
+interface ShareConvoOptions {
+    to?: string[];
+    transcriptFile?: string;
+    nativeFile?: string;
+    sourceAgent?: string;
+    title?: string;
+    note?: string;
+    personal?: boolean;
+    ttlDays?: string;
+    metadataJson?: string;
+    metadataFile?: string;
+    workspace?: string;
+}
+export declare function runShareConvo(opts: ShareConvoOptions, command: Command, isPersonalAlias?: boolean): Promise<void>;
+export declare const shareConvoCommand: Command;
+export {};

package/dist/commands/share-convo.js

@@ -0,0 +1,167 @@
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { createHash } from 'crypto';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { resolveWorkspace } from '../workspace/resolve.js';
+import { shouldOutputJson, jsonOut } from '../utils/output.js';
+import { detectCurrentAgent } from '../agents/runtime-detection.js';
+function nativeBundleFormatForAgent(slug) {
+    if (slug === 'claude-code' || slug === 'claude-desktop')
+        return 'claude-jsonl';
+    if (slug === 'codex' || slug === 'codex-app')
+        return 'codex-rollout';
+    return null;
+}
+function sha256Hex(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+function utf8ByteLength(content) {
+    return Buffer.byteLength(content, 'utf8');
+}
+export async function runShareConvo(opts, command, isPersonalAlias = false) {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    if (!opts.transcriptFile) {
+        console.error('Error: --transcript-file is required. Pass the path to the LLM-emitted markdown transcript.');
+        process.exit(1);
+    }
+    if (!existsSync(opts.transcriptFile)) {
+        console.error(`Error: transcript file does not exist: ${opts.transcriptFile}`);
+        process.exit(1);
+    }
+    if (!opts.title) {
+        console.error('Error: --title is required.');
+        process.exit(1);
+    }
+    const isPersonal = isPersonalAlias || !!opts.personal || (!opts.to || opts.to.length === 0);
+    const recipients = opts.to ?? [];
+    if (!isPersonal && recipients.length === 0) {
+        console.error('Error: at least one --to <email> is required (or use --personal to save for yourself)');
+        process.exit(1);
+    }
+    if (isPersonal && recipients.length > 0) {
+        console.error('Error: --personal and --to cannot be combined; personal shares are self-only');
+        process.exit(1);
+    }
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, { workspace: opts.workspace });
+    // Read transcript bundle (always required)
+    const transcriptContent = readFileSync(opts.transcriptFile, 'utf8');
+    const bundles = [
+        {
+            format: 'transcript',
+            content: transcriptContent,
+            sizeBytes: utf8ByteLength(transcriptContent),
+            sha256: sha256Hex(transcriptContent),
+        },
+    ];
+    // Detect host agent (for source tagging and native bundle pickup)
+    const detected = detectCurrentAgent();
+    const sourceAgent = opts.sourceAgent ?? detected?.slug ?? 'generic';
+    // Resolve native bundle - explicit --native-file wins, else use detection
+    let nativeFilePath = null;
+    if (opts.nativeFile) {
+        if (!existsSync(opts.nativeFile)) {
+            console.error(`Error: --native-file path does not exist: ${opts.nativeFile}`);
+            process.exit(1);
+        }
+        nativeFilePath = opts.nativeFile;
+    }
+    else if (detected?.sessionFilePath && existsSync(detected.sessionFilePath)) {
+        nativeFilePath = detected.sessionFilePath;
+    }
+    if (nativeFilePath) {
+        const nativeFormat = nativeBundleFormatForAgent(sourceAgent);
+        if (nativeFormat) {
+            try {
+                const content = readFileSync(nativeFilePath, 'utf8');
+                bundles.push({
+                    format: nativeFormat,
+                    content,
+                    sizeBytes: utf8ByteLength(content),
+                    sha256: sha256Hex(content),
+                });
+            }
+            catch (err) {
+                console.error(`Warning: could not read native file ${nativeFilePath}: ${err instanceof Error ? err.message : err}`);
+                console.error('Continuing with transcript-only bundle.');
+            }
+        }
+    }
+    // Metadata - merge --metadata-json and --metadata-file
+    let metadata = {};
+    if (opts.metadataFile) {
+        try {
+            metadata = JSON.parse(readFileSync(opts.metadataFile, 'utf8'));
+        }
+        catch (err) {
+            console.error(`Error: --metadata-file is not valid JSON: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+    }
+    if (opts.metadataJson) {
+        try {
+            metadata = { ...metadata, ...JSON.parse(opts.metadataJson) };
+        }
+        catch (err) {
+            console.error(`Error: --metadata-json is not valid JSON: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+    }
+    // Augment metadata with detected host info if not already provided
+    if (detected && !metadata.sourceSessionId) {
+        metadata.sourceSessionId = detected.sessionId;
+    }
+    if (!metadata.os) {
+        metadata.os = process.platform === 'darwin' ? 'macos' : process.platform === 'win32' ? 'windows' : 'linux';
+    }
+    const ttlDays = opts.ttlDays ? parseInt(opts.ttlDays, 10) : undefined;
+    try {
+        const result = await client.createSharedConversation(workspaceId, {
+            recipients: isPersonal ? [] : recipients,
+            isPersonal,
+            sourceAgent,
+            title: opts.title,
+            note: opts.note,
+            bundles,
+            metadata,
+            ttlDays: ttlDays && Number.isFinite(ttlDays) ? ttlDays : undefined,
+        });
+        if (useJson) {
+            jsonOut(result);
+            return;
+        }
+        if (isPersonal) {
+            console.log(`Saved conversation: ${result.share.title}`);
+            console.log(`Share ID: ${result.share.id}`);
+            console.log(`Expires: ${result.share.expiresAt}`);
+            console.log(`\nResume with: runwork resume ${result.share.id}`);
+        }
+        else {
+            console.log(`Shared with ${result.sharedCount} member${result.sharedCount === 1 ? '' : 's'}` +
+                (result.invitedCount > 0 ? ` and invited ${result.invitedCount} new user${result.invitedCount === 1 ? '' : 's'}` : '') + '.');
+            console.log(`Share ID: ${result.share.id}`);
+            if (result.skipped.length > 0) {
+                console.log(`\nSkipped: ${result.skipped.map(s => `${s.identifier} (${s.reason})`).join(', ')}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Failed to share conversation: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}
+export const shareConvoCommand = new Command('share-convo')
+    .description('Share the current AI conversation with a teammate')
+    .option('--to <email>', 'Recipient email (repeatable)', (value, prev = []) => [...prev, value], [])
+    .option('--transcript-file <path>', 'Path to the LLM-emitted markdown transcript (required)')
+    .option('--native-file <path>', 'Path to the native session file (optional; auto-detected from env vars otherwise)')
+    .option('--source-agent <slug>', 'Override host-agent detection (e.g. claude-code, codex, claude-desktop)')
+    .option('--title <string>', 'Short title for the conversation (required)')
+    .option('--note <string>', 'Optional personal note to recipients')
+    .option('--ttl-days <n>', 'Days until expiration (1-30, default 7)')
+    .option('--metadata-json <json>', 'Inline JSON object with workMode, openQuestions, suggestedNextStep, etc.')
+    .option('--metadata-file <path>', 'Path to a JSON file with the same metadata fields')
+    .option('--workspace <id>', 'Workspace ID')
+    .action((opts, command) => runShareConvo(opts, command, false));

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) {
@@ -293,6 +310,7 @@ export async function syncFromState(state, statePath, credentials, opts) {
         appCount: allSkills.filter(s => s.type === 'app').length,
         skillCount: remoteSkills.length,
         mcpServerCount: mcpEntries.length,
+        persona: state.persona,
     });
     // For project scope: determine which app skill to include (only current app's skill)
     let projectAppSkillFilter = null;
@@ -305,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.
@@ -315,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;
@@ -324,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
@@ -568,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')