@vellumai/assistant 0.6.6 → 0.7.1

package/src/daemon/handlers/skills.ts

@@ -31,6 +31,7 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../providers/provider-send-message.js";
+import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import {
   isTextMimeType as isTextMime,
   MAX_INLINE_TEXT_SIZE,
@@ -50,7 +51,6 @@ import {
   upsertSkillsIndex,
 } from "../../skills/catalog-install.js";
 import { filterByQuery } from "../../skills/catalog-search.js";
-import type { SkillCategory } from "../../skills/category-inference.js";
 import { inferCategory } from "../../skills/category-inference.js";
 import {
   clawhubCheckUpdates,
@@ -81,35 +81,14 @@ import {
   type SkillAuditData,
 } from "../../skills/skillssh-registry.js";
 import { getWorkspaceSkillsDir } from "../../util/platform.js";
+import { getConfigWatcher } from "../config-watcher.js";
+import { maybeSeedMemoryV2Skills } from "../memory-v2-startup.js";
 import type {
   SkillDetailResponse,
   SkillFileContentResponse,
   SlimSkillResponse,
 } from "../message-types/skills.js";
-
-// Re-export for use by route layer and future consumers.
-export type { SkillCategory };
-export { inferCategory };
-import {
-  CONFIG_RELOAD_DEBOUNCE_MS,
-  ensureSkillEntry,
-  type HandlerContext,
-  log,
-} from "./shared.js";
-
-// ─── Shared context for standalone functions ─────────────────────────────────
-
-/**
- * Minimal context needed by the standalone skill business-logic functions.
- * HandlerContext satisfies this interface, but HTTP routes can also provide
- * a compatible object without coupling to handler internals.
- */
-export interface SkillOperationContext {
-  debounceTimers: HandlerContext["debounceTimers"];
-  setSuppressConfigReload(value: boolean): void;
-  updateConfigFingerprint(): void;
-  broadcast: HandlerContext["broadcast"];
-}
+import { CONFIG_RELOAD_DEBOUNCE_MS, ensureSkillEntry, log } from "./shared.js";
 
 // ─── Provider chain for uninstalled skill file preview ───────────────────────
 // Ordered by priority: vellum first (most common and cheapest to check),
@@ -257,28 +236,25 @@ const LLM_DRAFT_TIMEOUT_MS = 15_000;
 // These are consumed by both the handlers below and the HTTP route layer.
 
 /** Helper: suppress config reload, save, debounce, and update fingerprint. */
-function saveConfigWithSuppression(
-  raw: Record<string, unknown>,
-  ctx: SkillOperationContext,
-): void {
-  ctx.setSuppressConfigReload(true);
+function saveConfigWithSuppression(raw: Record<string, unknown>): void {
+  getConfigWatcher().suppressConfigReload = true;
   try {
     saveRawConfig(raw);
   } catch (err) {
-    ctx.setSuppressConfigReload(false);
+    getConfigWatcher().suppressConfigReload = false;
     throw err;
   }
   invalidateConfigCache();
 
-  ctx.debounceTimers.schedule(
+  getConfigWatcher().timers.schedule(
     "__suppress_reset__",
     () => {
-      ctx.setSuppressConfigReload(false);
+      getConfigWatcher().suppressConfigReload = false;
     },
     CONFIG_RELOAD_DEBOUNCE_MS,
   );
 
-  ctx.updateConfigFingerprint();
+  getConfigWatcher().updateFingerprint();
 }
 
 /**
@@ -295,11 +271,7 @@ function saveConfigWithSuppression(
  * NOT used for bundled skills — those have a simpler inline path in
  * `installSkill()` that only auto-enables, broadcasts, and seeds memories.
  */
-export function postInstallSkill(
-  skillId: string,
-  _skillDir: string,
-  ctx: SkillOperationContext,
-): void {
+function postInstallSkill(skillId: string, _skillDir: string): void {
   // Reload skill catalog so the newly installed skill is picked up
   loadSkillCatalog();
 
@@ -307,8 +279,8 @@ export function postInstallSkill(
   try {
     const raw = loadRawConfig();
     ensureSkillEntry(raw, skillId).enabled = true;
-    saveConfigWithSuppression(raw, ctx);
-    ctx.broadcast({
+    saveConfigWithSuppression(raw);
+    broadcastMessage({
       type: "skills_state_changed",
       name: skillId,
       state: "enabled",
@@ -319,6 +291,7 @@ export function postInstallSkill(
 
   // Seed skill memories
   seedSkillGraphNodes();
+  maybeSeedMemoryV2Skills(getConfig());
   void seedUninstalledCatalogSkillMemories().catch(() => {});
 }
 
@@ -352,13 +325,6 @@ function deriveOrigin(
   return meta?.origin ?? "custom";
 }
 
-/** Sort rank by kind: bundled first, then catalog, then installed. */
-function kindSortRank(kind: SlimSkillResponse["kind"]): number {
-  if (kind === "bundled") return 0;
-  if (kind === "catalog") return 1;
-  return 2; // installed
-}
-
 /** Convert a resolved skill to a SlimSkillResponse. */
 function toSlimSkillResponse(
   summary: SkillSummary,
@@ -418,19 +384,16 @@ function toSlimSkillResponse(
   }
 }
 
-export function listSkills(_ctx: SkillOperationContext): SlimSkillResponse[] {
+export function listSkills(): SlimSkillResponse[] {
   const config = getConfig();
   const catalog = loadSkillCatalog();
   const resolved = resolveSkillStates(catalog, config);
 
   const items = resolved.map((r) => toSlimSkillResponse(r.summary, r.state));
 
-  // Sort by kind rank, then alphabetical by name within each tier.
-  items.sort((a, b) => {
-    const rankDiff = kindSortRank(a.kind) - kindSortRank(b.kind);
-    if (rankDiff !== 0) return rankDiff;
-    return a.name.localeCompare(b.name);
-  });
+  // Alphabetical by name — kind/source is a property on each skill, not a
+  // grouping axis. Keeps output stable as the catalog grows.
+  items.sort((a, b) => a.name.localeCompare(b.name));
 
   return items;
 }
@@ -439,10 +402,8 @@ export function listSkills(_ctx: SkillOperationContext): SlimSkillResponse[] {
  * List installed skills merged with available catalog skills.
  * Installed skills take precedence when deduplicating by ID.
  */
-export async function listSkillsWithCatalog(
-  ctx: SkillOperationContext,
-): Promise<SlimSkillResponse[]> {
-  const installed = listSkills(ctx);
+async function listSkillsWithCatalog(): Promise<SlimSkillResponse[]> {
+  const installed = listSkills();
   const installedIds = new Set(installed.map((s) => s.id));
 
   let catalogSkills: CatalogSkill[];
@@ -461,12 +422,8 @@ export async function listSkillsWithCatalog(
 
   const merged = [...installed, ...available];
 
-  // Sort by kind rank, then alphabetical by name
-  merged.sort((a, b) => {
-    const rankDiff = kindSortRank(a.kind) - kindSortRank(b.kind);
-    if (rankDiff !== 0) return rankDiff;
-    return a.name.localeCompare(b.name);
-  });
+  // Alphabetical by name — kind is a property on each skill, not a grouping axis.
+  merged.sort((a, b) => a.name.localeCompare(b.name));
 
   return merged;
 }
@@ -482,7 +439,7 @@ export interface SkillListFilter {
 }
 
 /** Human-readable labels matching Swift's `sourceLabel`. */
-export function originDisplayLabel(origin: string): string {
+function originDisplayLabel(origin: string): string {
   switch (origin) {
     case "vellum":
       return "Vellum";
@@ -498,7 +455,7 @@ export function originDisplayLabel(origin: string): string {
 }
 
 /** Check if a skill's origin matches a text query (matching Swift logic). */
-export function originMatchesQuery(origin: string, query: string): boolean {
+function originMatchesQuery(origin: string, query: string): boolean {
   const label = originDisplayLabel(origin).toLowerCase();
   if (label.includes(query)) return true;
   // "community" umbrella matches clawhub and skillssh
@@ -515,18 +472,15 @@ export function originMatchesQuery(origin: string, query: string): boolean {
  * List skills with filtering, category counts, and sorting.
  * Calls listSkillsWithCatalog for the full merged list, then applies filters.
  */
-export async function listSkillsFiltered(
-  filter: SkillListFilter,
-  ctx: SkillOperationContext,
-): Promise<{
+export async function listSkillsFiltered(filter: SkillListFilter): Promise<{
   skills: SlimSkillResponse[];
   categoryCounts: Record<string, number>;
   totalCount: number;
 }> {
   let skills =
     filter.includeCatalog !== false
-      ? await listSkillsWithCatalog(ctx)
-      : listSkills(ctx);
+      ? await listSkillsWithCatalog()
+      : listSkills();
 
   // Apply origin filter
   if (filter.origin) {
@@ -620,7 +574,6 @@ function findSkillById(
 
 export async function getSkill(
   skillId: string,
-  _ctx: SkillOperationContext,
 ): Promise<{ skill: SkillDetailResponse } | { error: string; status: number }> {
   const found = findSkillById(skillId);
   if (!found) {
@@ -824,7 +777,6 @@ function readDirRecursive(dir: string, rootDir: string): SkillFileEntry[] {
 export async function getSkillFileContent(
   skillId: string,
   relativePath: string,
-  _ctx: SkillOperationContext,
 ): Promise<SkillFileContentResponse | { error: string; status: number }> {
   const sanitized = sanitizeRelativePath(relativePath);
   if (!sanitized) {
@@ -947,7 +899,6 @@ export async function getSkillFileContent(
 
 export async function getSkillFiles(
   skillId: string,
-  _ctx: SkillOperationContext,
 ): Promise<
   | { skill: SlimSkillResponse; files: SkillFileEntry[] }
   | { error: string; status: number }
@@ -988,18 +939,18 @@ export async function getSkillFiles(
 
 export function enableSkill(
   skillId: string,
-  ctx: SkillOperationContext,
 ): { success: true } | { success: false; error: string } {
   try {
     const raw = loadRawConfig();
     ensureSkillEntry(raw, skillId).enabled = true;
-    saveConfigWithSuppression(raw, ctx);
-    ctx.broadcast({
+    saveConfigWithSuppression(raw);
+    broadcastMessage({
       type: "skills_state_changed",
       name: skillId,
       state: "enabled",
     });
     seedSkillGraphNodes();
+    maybeSeedMemoryV2Skills(getConfig());
     void seedUninstalledCatalogSkillMemories().catch(() => {});
     return { success: true };
   } catch (err) {
@@ -1011,18 +962,18 @@ export function enableSkill(
 
 export function disableSkill(
   skillId: string,
-  ctx: SkillOperationContext,
 ): { success: true } | { success: false; error: string } {
   try {
     const raw = loadRawConfig();
     ensureSkillEntry(raw, skillId).enabled = false;
-    saveConfigWithSuppression(raw, ctx);
-    ctx.broadcast({
+    saveConfigWithSuppression(raw);
+    broadcastMessage({
       type: "skills_state_changed",
       name: skillId,
       state: "disabled",
     });
     seedSkillGraphNodes();
+    maybeSeedMemoryV2Skills(getConfig());
     void seedUninstalledCatalogSkillMemories().catch(() => {});
     return { success: true };
   } catch (err) {
@@ -1039,7 +990,6 @@ export function configureSkill(
     apiKey?: string;
     config?: Record<string, unknown>;
   },
-  ctx: SkillOperationContext,
 ): { success: true } | { success: false; error: string } {
   try {
     const raw = loadRawConfig();
@@ -1047,7 +997,7 @@ export function configureSkill(
     if (config.env) entry.env = config.env;
     if (config.apiKey !== undefined) entry.apiKey = config.apiKey;
     if (config.config) entry.config = config.config;
-    saveConfigWithSuppression(raw, ctx);
+    saveConfigWithSuppression(raw);
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1064,15 +1014,12 @@ function looksLikeSkillsShSlug(slug: string): boolean {
   return slug.split("/").length >= 3;
 }
 
-export async function installSkill(
-  spec: {
-    slug: string;
-    version?: string;
-    origin?: "clawhub" | "skillssh";
-    contactId?: string;
-  },
-  ctx: SkillOperationContext,
-): Promise<
+export async function installSkill(spec: {
+  slug: string;
+  version?: string;
+  origin?: "clawhub" | "skillssh";
+  contactId?: string;
+}): Promise<
   { success: true; skillId: string } | { success: false; error: string }
 > {
   try {
@@ -1105,8 +1052,8 @@ export async function installSkill(
       try {
         const raw = loadRawConfig();
         ensureSkillEntry(raw, spec.slug).enabled = true;
-        saveConfigWithSuppression(raw, ctx);
-        ctx.broadcast({
+        saveConfigWithSuppression(raw);
+        broadcastMessage({
           type: "skills_state_changed",
           name: spec.slug,
           state: "enabled",
@@ -1118,6 +1065,7 @@ export async function installSkill(
         );
       }
       seedSkillGraphNodes();
+      maybeSeedMemoryV2Skills(config);
       void seedUninstalledCatalogSkillMemories().catch(() => {});
       return { success: true, skillId: spec.slug };
     }
@@ -1139,7 +1087,7 @@ export async function installSkill(
           );
 
           const skillDir = join(getWorkspaceSkillsDir(), spec.slug);
-          postInstallSkill(spec.slug, skillDir, ctx);
+          postInstallSkill(spec.slug, skillDir);
           return { success: true, skillId: spec.slug };
         }
       } catch (err) {
@@ -1167,7 +1115,7 @@ export async function installSkill(
       );
 
       const skillDir = join(getWorkspaceSkillsDir(), resolved.skillSlug);
-      postInstallSkill(resolved.skillSlug, skillDir, ctx);
+      postInstallSkill(resolved.skillSlug, skillDir);
       return { success: true, skillId: resolved.skillSlug };
     }
 
@@ -1195,7 +1143,7 @@ export async function installSkill(
     }
     upsertSkillsIndex(skillId);
 
-    postInstallSkill(skillId, skillDir, ctx);
+    postInstallSkill(skillId, skillDir);
     return { success: true, skillId };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1206,7 +1154,6 @@ export async function installSkill(
 
 export async function uninstallSkill(
   skillId: string,
-  ctx: SkillOperationContext,
 ): Promise<{ success: true } | { success: false; error: string }> {
   // Validate skill name to prevent path traversal while allowing namespaced slugs (org/name)
   const validNamespacedSlug =
@@ -1254,10 +1201,10 @@ export async function uninstallSkill(
     const entries = skills?.entries as Record<string, unknown> | undefined;
     if (entries?.[skillId]) {
       delete entries[skillId];
-      saveConfigWithSuppression(raw, ctx);
+      saveConfigWithSuppression(raw);
     }
 
-    ctx.broadcast({
+    broadcastMessage({
       type: "skills_state_changed",
       name: skillId,
       state: "uninstalled",
@@ -1273,7 +1220,6 @@ export async function uninstallSkill(
 
 export async function updateSkill(
   skillId: string,
-  _ctx: SkillOperationContext,
 ): Promise<{ success: true } | { success: false; error: string }> {
   try {
     const result = await clawhubUpdate(skillId);
@@ -1290,9 +1236,7 @@ export async function updateSkill(
   }
 }
 
-export async function checkSkillUpdates(
-  _ctx: SkillOperationContext,
-): Promise<
+export async function checkSkillUpdates(): Promise<
   { success: true; data: unknown } | { success: false; error: string }
 > {
   try {
@@ -1307,7 +1251,6 @@ export async function checkSkillUpdates(
 
 export async function searchSkills(
   query: string,
-  _ctx: SkillOperationContext,
 ): Promise<
   | { success: true; skills: SlimSkillResponse[] }
   | { success: false; error: string }
@@ -1470,7 +1413,6 @@ export async function searchSkills(
 
 export async function inspectSkill(
   skillId: string,
-  _ctx: SkillOperationContext,
 ): Promise<{ slug: string; data?: ClawhubInspectResult; error?: string }> {
   try {
     const result = await clawhubInspect(skillId);
@@ -1499,10 +1441,9 @@ export interface DraftResult {
   error?: string;
 }
 
-export async function draftSkill(
-  params: { sourceText: string },
-  _ctx: SkillOperationContext,
-): Promise<DraftResult> {
+export async function draftSkill(params: {
+  sourceText: string;
+}): Promise<DraftResult> {
   try {
     const warnings: string[] = [];
     const parsed = parseFrontmatter(params.sourceText);
@@ -1654,7 +1595,6 @@ export interface CreateSkillParams {
 
 export async function createSkill(
   params: CreateSkillParams,
-  ctx: SkillOperationContext,
 ): Promise<{ success: true } | { success: false; error: string }> {
   try {
     const result = createManagedSkill({
@@ -1678,8 +1618,8 @@ export async function createSkill(
     try {
       const raw = loadRawConfig();
       ensureSkillEntry(raw, params.skillId).enabled = true;
-      saveConfigWithSuppression(raw, ctx);
-      ctx.broadcast({
+      saveConfigWithSuppression(raw);
+      broadcastMessage({
         type: "skills_state_changed",
         name: params.skillId,
         state: "enabled",
@@ -1692,6 +1632,7 @@ export async function createSkill(
     }
 
     seedSkillGraphNodes();
+    maybeSeedMemoryV2Skills(getConfig());
     void seedUninstalledCatalogSkillMemories().catch(() => {});
     return { success: true };
   } catch (err) {

package/src/daemon/host-bash-proxy.ts

@@ -1,6 +1,11 @@
 import { v4 as uuid } from "uuid";
 
 import { getConfig } from "../config/loader.js";
+import {
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { formatShellOutput } from "../tools/shared/shell-output.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -14,30 +19,53 @@ interface PendingRequest {
   reject: (err: Error) => void;
   timer: ReturnType<typeof setTimeout>;
   timeoutSec: number;
+  conversationId: string;
   /** Detach the abort listener from the caller's signal. No-op when no signal was passed. */
   detachAbort: () => void;
 }
 
 export class HostBashProxy {
+  private static _instance: HostBashProxy | null = null;
+
+  /**
+   * Lazily-initialized singleton. Availability of an actual desktop
+   * connection is checked at send time via the assistant event hub,
+   * not at construction time.
+   */
+  static get instance(): HostBashProxy {
+    if (!HostBashProxy._instance) {
+      log.info("Creating singleton HostBashProxy");
+      HostBashProxy._instance = new HostBashProxy();
+    }
+    return HostBashProxy._instance;
+  }
+
+  /** Dispose the singleton. Called during graceful shutdown. */
+  static disposeInstance(): void {
+    if (HostBashProxy._instance) {
+      HostBashProxy._instance.dispose();
+      HostBashProxy._instance = null;
+    }
+  }
+
+  /** For tests. */
+  static reset(): void {
+    HostBashProxy._instance = null;
+  }
+
   private pending = new Map<string, PendingRequest>();
-  private sendToClient: (msg: ServerMessage) => void;
-  private onInternalResolve?: (requestId: string) => void;
-  private clientConnected = false;
-
-  constructor(
-    sendToClient: (msg: ServerMessage) => void,
-    onInternalResolve?: (requestId: string) => void,
-  ) {
-    this.sendToClient = sendToClient;
-    this.onInternalResolve = onInternalResolve;
+
+  /**
+   * Whether a client with `host_bash` capability is connected.
+   */
+  isAvailable(): boolean {
+    return (
+      assistantEventHub.getMostRecentClientByCapability("host_bash") != null
+    );
   }
 
-  updateSender(
-    sendToClient: (msg: ServerMessage) => void,
-    clientConnected: boolean,
-  ): void {
-    this.sendToClient = sendToClient;
-    this.clientConnected = clientConnected;
+  private send(msg: ServerMessage): void {
+    broadcastMessage(msg, undefined, { targetCapability: "host_bash" });
   }
 
   request(
@@ -70,7 +98,7 @@ export class HostBashProxy {
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
         detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn(
           { requestId, command: input.command },
           "Host bash proxy request timed out",
@@ -91,15 +119,14 @@ export class HostBashProxy {
           if (this.pending.has(requestId)) {
             clearTimeout(timer);
             this.pending.delete(requestId);
-            // Abort fired — nothing to detach, but call the no-op for symmetry
-            // so callers can rely on detachAbort being idempotent.
             detachAbort();
-            this.onInternalResolve?.(requestId);
+            pendingInteractions.resolve(requestId);
             try {
-              this.sendToClient({
+              this.send({
                 type: "host_bash_cancel",
                 requestId,
-              } as ServerMessage);
+                conversationId,
+              });
             } catch {
               // Best-effort cancel notification — connection may already be closed.
             }
@@ -115,11 +142,12 @@ export class HostBashProxy {
         reject,
         timer,
         timeoutSec,
+        conversationId,
         detachAbort,
       });
 
       try {
-        this.sendToClient({
+        this.send({
           type: "host_bash_request",
           requestId,
           conversationId,
@@ -127,17 +155,14 @@ export class HostBashProxy {
           working_dir: input.working_dir,
           timeout_seconds: input.timeout_seconds,
           ...(input.env && Object.keys(input.env).length > 0
-            ? { env: input.env }
-            : {}),
-        } as ServerMessage);
+              ? { env: input.env }
+              : {}),
+          });
       } catch (err) {
-        // Sender threw synchronously (e.g. client transport error during
-        // event emission). Clean up pending state and timer so we don't
-        // leak an in-flight entry that nothing will ever resolve.
         clearTimeout(timer);
         this.pending.delete(requestId);
         detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn(
           { requestId, command: input.command, err },
           "Host bash proxy send failed",
@@ -178,23 +203,20 @@ export class HostBashProxy {
     return this.pending.has(requestId);
   }
 
-  isAvailable(): boolean {
-    return this.clientConnected;
-  }
-
   dispose(): void {
     for (const [requestId, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.detachAbort();
-      this.onInternalResolve?.(requestId);
-      try {
-        this.sendToClient({
-          type: "host_bash_cancel",
-          requestId,
-        } as ServerMessage);
-      } catch {
-        // Best-effort cancel notification — connection may already be closed.
-      }
+        clearTimeout(entry.timer);
+        entry.detachAbort();
+        pendingInteractions.resolve(requestId);
+        try {
+          this.send({
+            type: "host_bash_cancel",
+            requestId,
+            conversationId: entry.conversationId,
+          });
+        } catch {
+          // Best-effort cancel notification — connection may already be closed.
+        }
       entry.reject(
         new AssistantError(
           "Host bash proxy disposed",