@vellumai/assistant 0.3.19 → 0.3.21

package/src/daemon/guardian-invite-intent.ts

@@ -0,0 +1,124 @@
+// Guardian invite intent resolution for deterministic first-turn routing.
+// Exports `resolveGuardianInviteIntent` as the single public entry point.
+// When a guardian invite management request is detected, the session pipeline
+// rewrites the message to force immediate entry into the trusted-contacts
+// skill flow, bypassing the normal agent loop's tendency to produce conceptual
+// preambles before loading the skill.
+
+export type GuardianInviteIntentResult =
+  | { kind: 'none' }
+  | { kind: 'invite_management'; rewrittenContent: string; action?: 'create' | 'list' | 'revoke' };
+
+// ── Direct invite patterns ────────────────────────────────────────────────
+// These capture imperative requests to manage Telegram invite links.
+
+const CREATE_INVITE_PATTERNS: RegExp[] = [
+  /\bcreate\s+(?:an?\s+)?(?:telegram\s+)?invite\s*(?:link)?\b/i,
+  /\binvite\s+(?:someone|somebody|a\s+friend|a\s+person)\s+(?:on|to|via|through)\s+telegram\b/i,
+  /\b(?:make|generate|get)\s+(?:a\s+|an\s+)?(?:telegram\s+)?invite\s*(?:link)?\b/i,
+  /\btelegram\s+invite\s*(?:link)?\b/i,
+  /\bsend\s+(?:a\s+|an\s+)?invite\s+(?:link\s+)?(?:on|for|via|through)\s+telegram\b/i,
+  /\bshare\s+(?:a\s+|an\s+)?(?:telegram\s+)?invite\s*(?:link)?\b/i,
+  /\binvite\s+(?:link\s+)?for\s+telegram\b/i,
+];
+
+const LIST_INVITE_PATTERNS: RegExp[] = [
+  /\b(?:show|list|view|see|display)\s+(?:my\s+)?(?:active\s+)?invite(?:s|\s*links?)\b/i,
+  /\b(?:show|list|view|see|display)\s+(?:my\s+)?(?:telegram\s+)?invite(?:s|\s*links?)\b/i,
+  /\bwhat\s+invite(?:s|\s*links?)\s+(?:do\s+I\s+have|are\s+active|exist)\b/i,
+  /\bhow\s+many\s+invite(?:s|\s*links?)\b/i,
+];
+
+const REVOKE_INVITE_PATTERNS: RegExp[] = [
+  /\b(?:revoke|cancel|disable|invalidate|delete|remove)\s+(?:the\s+|my\s+|an?\s+)?invite\s*(?:link)?\b/i,
+  /\b(?:revoke|cancel|disable|invalidate|delete|remove)\s+(?:the\s+|my\s+|an?\s+)?(?:telegram\s+)?invite\s*(?:link)?\b/i,
+  /\binvite\s*(?:link)?\s+(?:revoke|cancel|disable|invalidate|delete|remove)\b/i,
+];
+
+// ── Conceptual / question patterns ──────────────────────────────────────
+// These indicate the user is asking *about* invites rather than requesting
+// to manage them. Return passthrough for these.
+
+const CONCEPTUAL_PATTERNS: RegExp[] = [
+  /^\s*(?:how|what|why|when|where|who|which)\b.*\binvite/i,
+  /\bwhat\s+(?:is|are)\s+(?:an?\s+)?invite\s*(?:link)?\b/i,
+  /\bhow\s+(?:do|does|can)\s+(?:invite|invitation)s?\s+work\b/i,
+  /\bexplain\s+(?:the\s+)?invite\b/i,
+  /\btell\s+me\s+about\s+invite\b/i,
+];
+
+/** Common polite/filler words stripped before checking intent-only status. */
+const FILLER_PATTERN =
+  /\b(please|pls|plz|can\s+you|could\s+you|would\s+you|now|right\s+now|thanks|thank\s+you|thx|ty|for\s+me|ok(ay)?|hey|hi|hello|just|i\s+want\s+to|i'd\s+like\s+to|i\s+need\s+to|let's|let\s+me)\b/gi;
+
+// ── Internal helpers ─────────────────────────────────────────────────────
+
+function isConceptualQuestion(text: string): boolean {
+  const cleaned = text.replace(/^\s*(hey|hi|hello|please|pls|plz)[,\s]+/i, '');
+  // Allow actionable requests through even though they start with
+  // question-like words — these are imperative invite management requests.
+  if (LIST_INVITE_PATTERNS.some((p) => p.test(cleaned))) return false;
+  if (CREATE_INVITE_PATTERNS.some((p) => p.test(cleaned))) return false;
+  if (REVOKE_INVITE_PATTERNS.some((p) => p.test(cleaned))) return false;
+  return CONCEPTUAL_PATTERNS.some((p) => p.test(cleaned));
+}
+
+function detectAction(text: string): 'create' | 'list' | 'revoke' | undefined {
+  // Check revoke and list before create — create patterns include the broad
+  // `telegram invite link` matcher that would otherwise swallow revoke/list inputs.
+  if (REVOKE_INVITE_PATTERNS.some((p) => p.test(text))) return 'revoke';
+  if (LIST_INVITE_PATTERNS.some((p) => p.test(text))) return 'list';
+  if (CREATE_INVITE_PATTERNS.some((p) => p.test(text))) return 'create';
+  return undefined;
+}
+
+// ── Structured intent resolver ───────────────────────────────────────────
+
+/**
+ * Resolves guardian invite management intent from user text.
+ *
+ * Pipeline:
+ * 1. Skip slash commands entirely
+ * 2. Conceptual question gate -- questions return `none`
+ * 3. Detect create/list/revoke invite patterns
+ * 4. On match, build a deterministic model instruction to load trusted-contacts
+ */
+export function resolveGuardianInviteIntent(text: string): GuardianInviteIntentResult {
+  const trimmed = text.trim();
+
+  // Never intercept slash commands
+  if (trimmed.startsWith('/')) {
+    return { kind: 'none' };
+  }
+
+  // Conceptual questions pass through to normal agent processing
+  if (isConceptualQuestion(trimmed)) {
+    return { kind: 'none' };
+  }
+
+  // Strip fillers for pattern matching but keep original for context
+  const withoutFillers = trimmed.replace(FILLER_PATTERN, '').replace(/\s{2,}/g, ' ').trim();
+
+  const action = detectAction(withoutFillers);
+  if (!action) {
+    return { kind: 'none' };
+  }
+
+  // Build the rewritten content that deterministically loads the skill
+  const actionDescriptions: Record<string, string> = {
+    create: 'The user wants to create a Telegram invite link. Create the invite, look up the bot username, and present the shareable deep link with copy-paste instructions.',
+    list: 'The user wants to see their invite links. List all invites (especially active ones for Telegram) and present them in a readable format.',
+    revoke: 'The user wants to revoke an invite link. List invites to identify the target, confirm with the user, then revoke it.',
+  };
+
+  const rewrittenContent = [
+    actionDescriptions[action],
+    'Please invoke the "Trusted Contacts" skill (ID: trusted-contacts) immediately using skill_load.',
+  ].join('\n');
+
+  return {
+    kind: 'invite_management',
+    rewrittenContent,
+    action,
+  };
+}

package/src/daemon/handlers/avatar.ts

@@ -0,0 +1,68 @@
+import * as net from 'node:net';
+import { join } from 'node:path';
+
+import { setAvatarTool } from '../../tools/system/avatar-generator.js';
+import { getWorkspaceDir } from '../../util/platform.js';
+import type { GenerateAvatarRequest } from '../ipc-contract/settings.js';
+import { defineHandlers, type HandlerContext, log } from './shared.js';
+
+/**
+ * Handle a client request to generate a custom avatar via Gemini.
+ * Invokes the set_avatar tool directly, sends a response to the requesting
+ * client, and broadcasts avatar_updated to all clients on success.
+ */
+async function handleGenerateAvatar(
+  msg: GenerateAvatarRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  const description = msg.description?.trim();
+  if (!description) {
+    ctx.send(socket, {
+      type: 'generate_avatar_response',
+      success: false,
+      error: 'Description is required.',
+    });
+    return;
+  }
+
+  log.info({ description }, 'Generating avatar via IPC request');
+
+  try {
+    const result = await setAvatarTool.execute(
+      { description },
+      // Minimal tool context — avatar generation needs no session context
+      {} as Parameters<typeof setAvatarTool.execute>[1],
+    );
+
+    if (result.isError) {
+      ctx.send(socket, {
+        type: 'generate_avatar_response',
+        success: false,
+        error: result.content,
+      });
+      return;
+    }
+
+    // Broadcast avatar change to all connected clients
+    const avatarPath = join(getWorkspaceDir(), 'data', 'avatar', 'custom-avatar.png');
+    ctx.broadcast({ type: 'avatar_updated', avatarPath });
+
+    ctx.send(socket, {
+      type: 'generate_avatar_response',
+      success: true,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ error: message }, 'Avatar generation failed unexpectedly');
+    ctx.send(socket, {
+      type: 'generate_avatar_response',
+      success: false,
+      error: message,
+    });
+  }
+}
+
+export const avatarHandlers = defineHandlers({
+  generate_avatar: handleGenerateAvatar,
+});

package/src/daemon/handlers/browser.ts

@@ -1,4 +1,4 @@
-import { browserManager } from '../../tools/browser/browser-manager.js';
+import { browserManager, SCREENCAST_HEIGHT,SCREENCAST_WIDTH } from '../../tools/browser/browser-manager.js';
 import { defineHandlers,log } from './shared.js';
 
 export const browserHandlers = defineHandlers({
@@ -10,7 +10,7 @@ export const browserHandlers = defineHandlers({
     try {
       const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
       const viewport = await page.evaluate('(() => ({ vw: window.innerWidth, vh: window.innerHeight }))()') as { vw: number; vh: number };
-      const scale = Math.min(1280 / viewport.vw, 960 / viewport.vh);
+      const scale = Math.min(SCREENCAST_WIDTH / viewport.vw, SCREENCAST_HEIGHT / viewport.vh);
       const pageX = msg.x / scale;
       const pageY = msg.y / scale;
       const options: Record<string, unknown> = {};

package/src/daemon/handlers/guardian-actions.ts

@@ -0,0 +1,120 @@
+import { applyGuardianDecision } from '../../approvals/guardian-decision-primitive.js';
+import { getPendingApprovalForRequest } from '../../memory/channel-guardian-store.js';
+import type { ApprovalAction } from '../../runtime/channel-approval-types.js';
+import { handleChannelDecision } from '../../runtime/channel-approvals.js';
+import * as pendingInteractions from '../../runtime/pending-interactions.js';
+import { handleAccessRequestDecision } from '../../runtime/routes/access-request-decision.js';
+import { listGuardianDecisionPrompts } from '../../runtime/routes/guardian-action-routes.js';
+import type { GuardianActionDecision, GuardianActionsPendingRequest } from '../ipc-protocol.js';
+import { defineHandlers, log } from './shared.js';
+
+const VALID_ACTIONS = new Set<string>(['approve_once', 'approve_always', 'reject']);
+
+export const guardianActionsHandlers = defineHandlers({
+  guardian_actions_pending_request: (msg: GuardianActionsPendingRequest, socket, ctx) => {
+    const prompts = listGuardianDecisionPrompts({ conversationId: msg.conversationId });
+    ctx.send(socket, { type: 'guardian_actions_pending_response', conversationId: msg.conversationId, prompts });
+  },
+
+  guardian_action_decision: (msg: GuardianActionDecision, socket, ctx) => {
+    // Validate the action is one of the known actions
+    if (!VALID_ACTIONS.has(msg.action)) {
+      log.warn({ requestId: msg.requestId, action: msg.action }, 'Invalid guardian action');
+      ctx.send(socket, {
+        type: 'guardian_action_decision_response',
+        applied: false,
+        reason: 'invalid_action',
+        requestId: msg.requestId,
+      });
+      return;
+    }
+
+    // Try the channel guardian approval store first (tool approval prompts)
+    const approval = getPendingApprovalForRequest(msg.requestId);
+    if (approval) {
+      // Enforce conversationId scoping when provided.
+      if (msg.conversationId && msg.conversationId !== approval.conversationId) {
+        log.warn({ requestId: msg.requestId, expected: approval.conversationId, got: msg.conversationId }, 'conversationId mismatch');
+        ctx.send(socket, {
+          type: 'guardian_action_decision_response',
+          applied: false,
+          reason: 'conversation_mismatch',
+          requestId: msg.requestId,
+        });
+        return;
+      }
+
+      // Access request approvals need a separate decision path — they don't have
+      // pending interactions and use verification sessions instead.
+      if (approval.toolName === 'ingress_access_request') {
+        const mappedAction = msg.action === 'reject' ? 'deny' as const : 'approve' as const;
+        // Use 'desktop' as the actor identity because this endpoint is
+        // unauthenticated — we cannot verify the caller is the assigned
+        // guardian, so we record a generic desktop origin instead of
+        // falsely attributing the decision to guardianExternalUserId.
+        const decisionResult = handleAccessRequestDecision(
+          approval,
+          mappedAction,
+          'desktop',
+        );
+        ctx.send(socket, {
+          type: 'guardian_action_decision_response',
+          applied: decisionResult.type !== 'stale',
+          requestId: msg.requestId,
+          reason: decisionResult.type === 'stale' ? 'stale' : undefined,
+        });
+        return;
+      }
+
+      const result = applyGuardianDecision({
+        approval,
+        decision: { action: msg.action as 'approve_once' | 'approve_always' | 'reject', source: 'plain_text', requestId: msg.requestId },
+        actorExternalUserId: undefined,
+        actorChannel: 'vellum',
+      });
+      ctx.send(socket, {
+        type: 'guardian_action_decision_response',
+        applied: result.applied,
+        reason: result.reason,
+        requestId: result.requestId ?? msg.requestId,
+      });
+      return;
+    }
+
+    // Fall back to the pending interactions tracker (direct confirmation requests).
+    // Route through handleChannelDecision so approve_always properly persists trust rules.
+    const interaction = pendingInteractions.get(msg.requestId);
+    if (interaction) {
+      // Enforce conversationId scoping when provided.
+      if (msg.conversationId && msg.conversationId !== interaction.conversationId) {
+        log.warn({ requestId: msg.requestId, expected: interaction.conversationId, got: msg.conversationId }, 'conversationId mismatch');
+        ctx.send(socket, {
+          type: 'guardian_action_decision_response',
+          applied: false,
+          reason: 'conversation_mismatch',
+          requestId: msg.requestId,
+        });
+        return;
+      }
+
+      const result = handleChannelDecision(
+        interaction.conversationId,
+        { action: msg.action as ApprovalAction, source: 'plain_text', requestId: msg.requestId },
+      );
+      ctx.send(socket, {
+        type: 'guardian_action_decision_response',
+        applied: result.applied,
+        requestId: result.requestId ?? msg.requestId,
+      });
+      return;
+    }
+
+    log.warn({ requestId: msg.requestId }, 'No pending guardian action found for requestId');
+    ctx.send(socket, {
+      type: 'guardian_action_decision_response',
+      applied: false,
+      reason: 'not_found',
+      requestId: msg.requestId,
+    });
+  },
+});

package/src/daemon/handlers/index.ts

@@ -6,6 +6,7 @@ import type { ClientMessage } from '../ipc-protocol.js';
 import { handleRideShotgunStart, handleRideShotgunStop } from '../ride-shotgun-handler.js';
 import { handleWatchObservation } from '../watch-handler.js';
 import { appHandlers } from './apps.js';
+import { avatarHandlers } from './avatar.js';
 import { browserHandlers } from './browser.js';
 import { computerUseHandlers } from './computer-use.js';
 import { configHandlers } from './config.js';
@@ -13,6 +14,7 @@ import { inboxInviteHandlers } from './config-inbox.js';
 import { diagnosticsHandlers } from './diagnostics.js';
 import { dictationHandlers } from './dictation.js';
 import { documentHandlers } from './documents.js';
+import { guardianActionsHandlers } from './guardian-actions.js';
 import { homeBaseHandlers } from './home-base.js';
 import { identityHandlers } from './identity.js';
 import { miscHandlers } from './misc.js';
@@ -140,6 +142,7 @@ const handlers = {
   ...sessionHandlers,
   ...skillHandlers,
   ...appHandlers,
+  ...avatarHandlers,
   ...configHandlers,
   ...computerUseHandlers,
   ...publishHandlers,
@@ -147,6 +150,7 @@ const handlers = {
   ...diagnosticsHandlers,
   ...miscHandlers,
   ...documentHandlers,
+  ...guardianActionsHandlers,
   ...workItemHandlers,
   ...subagentHandlers,
   ...browserHandlers,

package/src/daemon/handlers/sessions.ts

@@ -24,6 +24,7 @@ import type {
   HistoryRequest,
   MessageContentRequest,
   RegenerateRequest,
+  ReorderThreadsRequest,
   SandboxSetRequest,
   SecretResponse,
   ServerMessage,
@@ -547,6 +548,7 @@ export function handleSessionList(socket: net.Socket, ctx: HandlerContext, offse
   const conversationIds = conversations.map((c) => c.id);
   const bindings = externalConversationStore.getBindingsForConversations(conversationIds);
   const attentionStates = getAttentionStateByConversationIds(conversationIds);
+  const displayMetas = conversationStore.getDisplayMetaForConversations(conversationIds);
   ctx.send(socket, {
     type: 'session_list_response',
     sessions: conversations.map((c) => {
@@ -554,6 +556,7 @@ export function handleSessionList(socket: net.Socket, ctx: HandlerContext, offse
       const originChannel = parseChannelId(c.originChannel);
       const originInterface = parseInterfaceId(c.originInterface);
       const attn = attentionStates.get(c.id);
+      const displayMeta = displayMetas.get(c.id);
       const assistantAttention = attn ? {
         hasUnseenLatestAssistantMessage: attn.latestAssistantMessageAt != null &&
           (attn.lastSeenAssistantMessageAt == null || attn.lastSeenAssistantMessageAt < attn.latestAssistantMessageAt),
@@ -581,6 +584,8 @@ export function handleSessionList(socket: net.Socket, ctx: HandlerContext, offse
         ...(originChannel ? { conversationOriginChannel: originChannel } : {}),
         ...(originInterface ? { conversationOriginInterface: originInterface } : {}),
         ...(assistantAttention ? { assistantAttention } : {}),
+        ...(displayMeta?.displayOrder != null ? { displayOrder: displayMeta.displayOrder } : {}),
+        ...(displayMeta?.isPinned ? { isPinned: displayMeta.isPinned } : {}),
       };
     }),
     hasMore: offset + conversations.length < totalCount,
@@ -1145,6 +1150,19 @@ export function handleMessageContentRequest(
   });
 }
 
+export function handleReorderThreads(
+  msg: ReorderThreadsRequest,
+  _socket: net.Socket,
+  _ctx: HandlerContext,
+): void {
+  if (!Array.isArray(msg.updates)) {
+    return;
+  }
+  conversationStore.batchSetDisplayOrders(
+    msg.updates.map((u) => ({ id: u.sessionId, displayOrder: u.displayOrder ?? null, isPinned: u.isPinned ?? false })),
+  );
+}
+
 export const sessionHandlers = defineHandlers({
   user_message: handleUserMessage,
   confirmation_response: handleConfirmationResponse,
@@ -1163,4 +1181,5 @@ export const sessionHandlers = defineHandlers({
   usage_request: handleUsageRequest,
   sandbox_set: handleSandboxSet,
   conversation_search: handleConversationSearch,
+  reorder_threads: handleReorderThreads,
 });

package/src/daemon/handlers/shared.ts

@@ -177,8 +177,10 @@ export function getScreenDimensions(): { width: number; height: number } {
   if (cachedScreenDims) return cachedScreenDims;
   if (process.platform !== 'darwin') return FALLBACK_SCREEN;
   try {
+    // Use osascript (JXA) instead of `swift` to avoid the
+    // "Install Command Line Developer Tools" popup on fresh macOS installs.
     const out = execSync(
-      `swift -e 'import CoreGraphics; let b = CGDisplayBounds(CGMainDisplayID()); print("\\(Int(b.width))x\\(Int(b.height))")'`,
+      `osascript -l JavaScript -e 'ObjC.import("AppKit"); var f = $.NSScreen.mainScreen.frame; Math.round(f.size.width) + "x" + Math.round(f.size.height)'`,
       { timeout: 10_000, encoding: 'utf-8' },
     ).trim();
     const [w, h] = out.split('x').map(Number);

package/src/daemon/install-cli-launchers.ts

@@ -1,24 +1,30 @@
 /**
  * Installs standalone CLI launcher scripts in ~/.vellum/bin/ so that
- * integration commands (e.g. `doordash`, `map`) can be invoked directly
- * without requiring `vellum` on PATH.
+ * integration commands (e.g. `map`) can be invoked directly without
+ * requiring `vellum` on PATH.
  *
  * Each launcher is a shell script that hardcodes absolute paths to `bun`
  * and the CLI entrypoint, forwarding all arguments to the appropriate
  * subcommand.
+ *
+ * Commands are split into two categories:
+ * - CORE_COMMANDS: always installed, dispatched via the main CLI entrypoint
+ * - Skill CLI launchers: dynamically discovered from installed skills that
+ *   declare a `cli` entry in their SKILL.md frontmatter metadata
  */
 
 import { execSync } from 'node:child_process';
-import { chmodSync,existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
+import { loadSkillCatalog } from '../config/skills.js';
 import { getLogger } from '../util/logger.js';
 
 const log = getLogger('install-cli-launchers');
 
-/** Integration subcommands that should get standalone launchers. */
-const INTEGRATION_COMMANDS = ['doordash', 'map'];
+/** Core subcommands dispatched via the main CLI entrypoint (index.ts). */
+const CORE_COMMANDS = ['map'];
 
 /**
  * Resolve the absolute path to the bun binary.
@@ -68,9 +74,13 @@ function hasSystemConflict(name: string, binDir: string): boolean {
  * Install standalone CLI launcher scripts in ~/.vellum/bin/.
  *
  * For each integration command, generates a shell script that execs
- * bun with the CLI entrypoint and the subcommand name prepended.
+ * bun with the appropriate entrypoint.
  * Uses the short name by default (e.g. `doordash`), falling back to
  * `vellum-<name>` if the short name conflicts with an existing system binary.
+ *
+ * Skill CLI launchers are discovered dynamically: any installed skill whose
+ * SKILL.md frontmatter declares `metadata.vellum.cli` will get a launcher
+ * pointing to the declared entry file within the skill directory.
  */
 export function installCliLaunchers(): void {
   const binDir = join(homedir(), '.vellum', 'bin');
@@ -83,13 +93,13 @@ export function installCliLaunchers(): void {
     return;
   }
 
-  const entrypoint = resolveCliEntrypoint();
-  if (!existsSync(entrypoint)) {
+  const mainEntrypoint = resolveCliEntrypoint();
+  if (!existsSync(mainEntrypoint)) {
     // In compiled builds (e.g. macOS app via `bun build --compile`), the
     // source tree isn't available.  Launcher scripts are a dev-mode
     // convenience; compiled builds use their own command dispatch, so we
     // silently skip installation.
-    log.debug({ entrypoint }, 'CLI entrypoint not found (compiled build?) — skipping launcher installation');
+    log.debug({ entrypoint: mainEntrypoint }, 'CLI entrypoint not found (compiled build?) — skipping launcher installation');
     return;
   }
 
@@ -97,18 +107,53 @@ export function installCliLaunchers(): void {
     mkdirSync(binDir, { recursive: true });
   }
 
-  for (const name of INTEGRATION_COMMANDS) {
+  const installed: string[] = [];
+
+  // Install core command launchers (dispatched via main CLI)
+  for (const name of CORE_COMMANDS) {
     const launcherName = hasSystemConflict(name, binDir) ? `vellum-${name}` : name;
     const launcherPath = join(binDir, launcherName);
 
     const script = `#!/bin/bash
-exec "${bunPath}" "${entrypoint}" ${name} "$@"
+exec "${bunPath}" "${mainEntrypoint}" ${name} "$@"
 `;
 
     writeFileSync(launcherPath, script);
     chmodSync(launcherPath, 0o755);
-    log.debug({ launcherName, launcherPath }, 'Installed CLI launcher');
+    installed.push(launcherName);
+    log.debug({ launcherName, launcherPath }, 'Installed core CLI launcher');
+  }
+
+  // Discover and install skill CLI launchers from the skill catalog
+  try {
+    const catalog = loadSkillCatalog();
+    for (const skill of catalog) {
+      const cli = skill.metadata?.cli;
+      if (!cli?.command || !cli?.entry) continue;
+
+      const entrypoint = join(skill.directoryPath, cli.entry);
+      if (!existsSync(entrypoint)) {
+        log.debug({ skillId: skill.id, entrypoint }, 'Skill CLI entry point not found — skipping');
+        continue;
+      }
+
+      const launcherName = hasSystemConflict(cli.command, binDir)
+        ? `vellum-${cli.command}`
+        : cli.command;
+      const launcherPath = join(binDir, launcherName);
+
+      const script = `#!/bin/bash
+exec "${bunPath}" "${entrypoint}" "$@"
+`;
+
+      writeFileSync(launcherPath, script);
+      chmodSync(launcherPath, 0o755);
+      installed.push(launcherName);
+      log.debug({ launcherName, launcherPath, skillId: skill.id }, 'Installed skill CLI launcher');
+    }
+  } catch (err) {
+    log.warn({ err }, 'Failed to discover skill CLI launchers');
   }
 
-  log.info({ binDir, commands: INTEGRATION_COMMANDS }, 'CLI launchers installed');
+  log.info({ binDir, commands: installed }, 'CLI launchers installed');
 }

package/src/daemon/ipc-contract/guardian-actions.ts

@@ -0,0 +1,53 @@
+// Guardian action decision IPC types.
+// Enables desktop clients to fetch pending guardian prompts and submit
+// button decisions deterministically (without text parsing).
+
+// === Client -> Server ===
+
+export interface GuardianActionsPendingRequest {
+  type: 'guardian_actions_pending_request';
+  conversationId: string;
+}
+
+export interface GuardianActionDecision {
+  type: 'guardian_action_decision';
+  requestId: string;
+  action: string;
+  conversationId?: string;
+}
+
+// === Server -> Client ===
+
+export interface GuardianActionsPendingResponse {
+  type: 'guardian_actions_pending_response';
+  conversationId: string;
+  prompts: Array<{
+    requestId: string;
+    requestCode: string;
+    state: string;
+    questionText: string;
+    toolName: string | null;
+    actions: Array<{ action: string; label: string }>;
+    expiresAt: number;
+    conversationId: string;
+    callSessionId: string | null;
+  }>;
+}
+
+export interface GuardianActionDecisionResponse {
+  type: 'guardian_action_decision_response';
+  applied: boolean;
+  reason?: string;
+  requestId?: string;
+  userText?: string;
+}
+
+// --- Domain-level union aliases (consumed by the barrel file) ---
+
+export type _GuardianActionsClientMessages =
+  | GuardianActionsPendingRequest
+  | GuardianActionDecision;
+
+export type _GuardianActionsServerMessages =
+  | GuardianActionsPendingResponse
+  | GuardianActionDecisionResponse;

package/src/daemon/ipc-contract/sessions.ts

@@ -156,6 +156,11 @@ export interface ConversationSearchRequest {
   maxMessagesPerConversation?: number;
 }
 
+export interface ReorderThreadsRequest {
+  type: 'reorder_threads';
+  updates: Array<{ sessionId: string; displayOrder: number | null; isPinned: boolean }>;
+}
+
 // === Server → Client ===
 
 export interface ConversationSearchMatchingMessage {
@@ -213,7 +218,7 @@ export interface AssistantAttention {
 
 export interface SessionListResponse {
   type: 'session_list_response';
-  sessions: Array<{ id: string; title: string; createdAt?: number; updatedAt: number; threadType?: ThreadType; source?: string; channelBinding?: ChannelBinding; conversationOriginChannel?: ChannelId; conversationOriginInterface?: InterfaceId; assistantAttention?: AssistantAttention }>;
+  sessions: Array<{ id: string; title: string; createdAt?: number; updatedAt: number; threadType?: ThreadType; source?: string; channelBinding?: ChannelBinding; conversationOriginChannel?: ChannelId; conversationOriginInterface?: InterfaceId; assistantAttention?: AssistantAttention; displayOrder?: number; isPinned?: boolean }>;
   /** Whether more sessions exist beyond the returned page. */
   hasMore?: boolean;
 }
@@ -392,7 +397,8 @@ export type _SessionsClientMessages =
   | SessionRenameRequest
   | SessionsClearRequest
   | ConversationSearchRequest
-  | MessageContentRequest;
+  | MessageContentRequest
+  | ReorderThreadsRequest;
 
 export type _SessionsServerMessages =
   | AuthResult