@vellumai/assistant 0.8.0 → 0.8.2

package/src/daemon/handlers/skills.ts

@@ -1,4 +1,3 @@
-import { execSync } from "node:child_process";
 import {
   existsSync,
   lstatSync,
@@ -8,7 +7,6 @@ import {
   rmSync,
   statSync,
 } from "node:fs";
-import { homedir } from "node:os";
 import { basename, join, relative, sep } from "node:path";
 
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
@@ -19,12 +17,9 @@ import {
   saveRawConfig,
 } from "../../config/loader.js";
 import { resolveSkillStates, skillFlagKey } from "../../config/skill-state.js";
-import { loadSkillCatalog, type SkillSummary } from "../../config/skills.js";
-import {
-  deleteSkillCapabilityNode,
-  seedSkillGraphNodes,
-  seedUninstalledCatalogSkillMemories,
-} from "../../memory/graph/capability-seed.js";
+import type { SkillSummary } from "../../config/skills.js";
+import { loadSkillCatalog } from "../../config/skills.js";
+import { deleteSkillCapabilityNode } from "../../memory/graph/capability-seed.js";
 import {
   createTimeout,
   extractText,
@@ -37,57 +32,56 @@ import {
   MAX_INLINE_TEXT_SIZE,
 } from "../../runtime/routes/workspace-utils.js";
 import { getCatalog } from "../../skills/catalog-cache.js";
+import type { SkillFileEntry } from "../../skills/catalog-files.js";
 import {
   catalogSkillToSlim,
   createVellumCatalogProvider,
   hasHiddenOrSkippedSegment,
   sanitizeRelativePath,
-  type SkillFileEntry,
   SKIP_DIRS,
 } from "../../skills/catalog-files.js";
+import type { CatalogSkill } from "../../skills/catalog-install.js";
 import {
-  type CatalogSkill,
+  commitStagedSkillInstall,
+  createSkillInstallStagingDir,
+  installSkillDependenciesIfPresent,
   installSkillLocally,
-  upsertSkillsIndex,
 } from "../../skills/catalog-install.js";
 import { filterByQuery } from "../../skills/catalog-search.js";
 import { inferCategory } from "../../skills/category-inference.js";
+import type { ClawhubInspectResult } from "../../skills/clawhub.js";
 import {
   clawhubCheckUpdates,
   clawhubInspect,
-  type ClawhubInspectResult,
   clawhubInstall,
   clawhubSearch,
   clawhubUpdate,
 } from "../../skills/clawhub.js";
 import { createClawhubProvider } from "../../skills/clawhub-files.js";
-import {
-  readInstallMeta,
-  type SkillInstallMeta,
-} from "../../skills/install-meta.js";
+import type { SkillInstallMeta } from "../../skills/install-meta.js";
+import { readInstallMeta } from "../../skills/install-meta.js";
 import {
   createManagedSkill,
   deleteManagedSkill,
-  removeSkillsIndexEntry,
   validateManagedSkillId,
 } from "../../skills/managed-store.js";
 import type { SkillFileProvider } from "../../skills/skill-file-provider.js";
 import { createSkillsShProvider } from "../../skills/skillssh-files.js";
+import type { SkillAuditData } from "../../skills/skillssh-registry.js";
 import {
   fetchSkillAudits,
   installExternalSkill,
   resolveSkillSource,
   searchSkillsRegistry,
-  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";
+import { refreshSkillCapabilityMemories } from "../skill-memory-refresh.js";
 import { CONFIG_RELOAD_DEBOUNCE_MS, ensureSkillEntry, log } from "./shared.js";
 
 // ─── Provider chain for uninstalled skill file preview ───────────────────────
@@ -262,19 +256,17 @@ function saveConfigWithSuppression(raw: Record<string, unknown>): void {
  * in the daemon. Handles catalog reload, auto-enable, broadcast, and memory
  * seeding.
  *
- * SKILLS.md indexing and dependency installation are handled separately:
- * `installSkillLocally` and `installExternalSkill` handle them internally
- * (so both CLI and daemon callers get correct behavior), while the clawhub
- * path handles them inline in `installSkill()` since `clawhubInstall` only
- * runs the clawhub CLI and writes metadata.
+ * Dependency installation is handled by the install path: catalog and
+ * skills.sh installs handle it internally, while the clawhub path stages the
+ * CLI output, installs dependencies, and commits the staged directory before
+ * this runs.
+ *
+ * Discoverability verification is handled by the install path before this runs.
  *
  * NOT used for bundled skills — those have a simpler inline path in
  * `installSkill()` that only auto-enables, broadcasts, and seeds memories.
  */
-function postInstallSkill(skillId: string, _skillDir: string): void {
-  // Reload skill catalog so the newly installed skill is picked up
-  loadSkillCatalog();
-
+function postInstallSkill(skillId: string): void {
   // Auto-enable the skill in config
   try {
     const raw = loadRawConfig();
@@ -290,9 +282,7 @@ function postInstallSkill(skillId: string, _skillDir: string): void {
   }
 
   // Seed skill memories
-  seedSkillGraphNodes();
-  maybeSeedMemoryV2Skills(getConfig());
-  void seedUninstalledCatalogSkillMemories().catch(() => {});
+  refreshSkillCapabilityMemories(getConfig());
 }
 
 // ─── Kind / origin / status derivation ───────────────────────────────────────
@@ -635,7 +625,9 @@ export async function getSkill(
         (detail as { owner?: typeof data.owner }).owner = data.owner;
         (detail as { stats?: typeof data.stats }).stats = data.stats;
         (
-          detail as { latestVersion?: typeof data.latestVersion }
+          detail as {
+            latestVersion?: typeof data.latestVersion;
+          }
         ).latestVersion = data.latestVersion;
         (detail as { createdAt?: typeof data.createdAt }).createdAt =
           data.createdAt;
@@ -691,6 +683,89 @@ export async function getSkill(
   return { skill: detail };
 }
 
+export function getSkillLocalDetail(skillId: string):
+  | {
+      ok: true;
+      id: string;
+      name: string;
+      description: string;
+      emoji: string | null;
+      source: string;
+      state: string;
+      directoryPath: string;
+      featureFlag: string | null;
+      includes: string[] | null;
+      activationHints: string[] | null;
+      avoidWhen: string[] | null;
+      toolManifest: {
+        valid: boolean;
+        toolCount: number;
+        toolNames: string[];
+      } | null;
+      installMeta: Record<string, unknown> | null;
+      config: {
+        enabled: boolean;
+        envKeys: string[];
+        configKeys: string[];
+      } | null;
+    }
+  | { ok: false; error: string; status: 404 | 500 } {
+  try {
+    const catalog = loadSkillCatalog();
+    const config = getConfig();
+    const resolved = resolveSkillStates(catalog, config);
+    const match = resolved.find((r) => r.summary.id === skillId);
+    if (!match) {
+      return {
+        ok: false,
+        error: `Skill "${skillId}" not found. Run 'assistant skills list' to see available skills.`,
+        status: 404,
+      };
+    }
+    const { summary, state, configEntry } = match;
+    const installMeta = readInstallMeta(summary.directoryPath);
+    return {
+      ok: true,
+      id: summary.id,
+      name: summary.displayName,
+      description: summary.description,
+      emoji: summary.emoji ?? null,
+      source: summary.source,
+      state,
+      directoryPath: summary.directoryPath,
+      featureFlag: summary.featureFlag ?? null,
+      includes: summary.includes ?? null,
+      activationHints: summary.activationHints ?? null,
+      avoidWhen: summary.avoidWhen ?? null,
+      toolManifest: summary.toolManifest
+        ? {
+            valid: summary.toolManifest.valid,
+            toolCount: summary.toolManifest.toolCount,
+            toolNames: summary.toolManifest.toolNames,
+          }
+        : null,
+      installMeta: installMeta
+        ? (installMeta as unknown as Record<string, unknown>)
+        : null,
+      config: configEntry
+        ? {
+            enabled: configEntry.enabled !== false,
+            envKeys: configEntry.env ? Object.keys(configEntry.env) : [],
+            configKeys: configEntry.config
+              ? Object.keys(configEntry.config)
+              : [],
+          }
+        : null,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      status: 500,
+    };
+  }
+}
+
 // ─── Skill file listing ──────────────────────────────────────────────────────
 
 // `SkillFileEntry` lives in `../../skills/catalog-files.ts` to keep a single
@@ -948,9 +1023,7 @@ export function enableSkill(
       name: skillId,
       state: "enabled",
     });
-    seedSkillGraphNodes();
-    maybeSeedMemoryV2Skills(getConfig());
-    void seedUninstalledCatalogSkillMemories().catch(() => {});
+    refreshSkillCapabilityMemories(getConfig());
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -971,9 +1044,7 @@ export function disableSkill(
       name: skillId,
       state: "disabled",
     });
-    seedSkillGraphNodes();
-    maybeSeedMemoryV2Skills(getConfig());
-    void seedUninstalledCatalogSkillMemories().catch(() => {});
+    refreshSkillCapabilityMemories(getConfig());
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1017,6 +1088,8 @@ export async function installSkill(spec: {
   slug: string;
   version?: string;
   origin?: "clawhub" | "skillssh";
+  catalogOnly?: boolean;
+  overwrite?: boolean;
   contactId?: string;
 }): Promise<
   { success: true; skillId: string } | { success: false; error: string }
@@ -1044,10 +1117,9 @@ export async function installSkill(spec: {
     if (bundled) {
       // Intentional divergence from postInstallSkill(): bundled skills are
       // shipped with the assistant binary and are already on disk. They skip
-      // SKILLS.md indexing (they're discovered via the bundled catalog, not
-      // the workspace index), dependency installation (deps are pre-bundled),
-      // and catalog reload (the catalog already includes them). Only
-      // auto-enable, broadcast, and seed memories are needed.
+      // dependency installation (deps are pre-bundled) and catalog reload (the
+      // catalog already includes them). Only auto-enable, broadcast, and seed
+      // memories are needed.
       try {
         const raw = loadRawConfig();
         ensureSkillEntry(raw, spec.slug).enabled = true;
@@ -1063,9 +1135,7 @@ export async function installSkill(spec: {
           "Failed to auto-enable bundled skill",
         );
       }
-      seedSkillGraphNodes();
-      maybeSeedMemoryV2Skills(config);
-      void seedUninstalledCatalogSkillMemories().catch(() => {});
+      refreshSkillCapabilityMemories(config);
       return { success: true, skillId: spec.slug };
     }
 
@@ -1078,25 +1148,40 @@ export async function installSkill(spec: {
         const vellumCatalog = await getCatalog();
         const catalogEntry = vellumCatalog.find((s) => s.id === spec.slug);
         if (catalogEntry) {
+          // Default `overwrite` to true at the handler boundary to preserve
+          // pre-existing HTTP API behaviour. CLI callers always pass an
+          // explicit boolean (`opts.overwrite ?? false`) so the CLI surface
+          // still defaults to non-destructive installs.
           await installSkillLocally(
             spec.slug,
             catalogEntry,
-            true,
+            spec.overwrite ?? true,
             spec.contactId,
           );
 
-          const skillDir = join(getWorkspaceSkillsDir(), spec.slug);
-          postInstallSkill(spec.slug, skillDir);
+          postInstallSkill(spec.slug);
           return { success: true, skillId: spec.slug };
         }
       } catch (err) {
-        // If catalog lookup/install fails, fall through to community registries
+        if (spec.catalogOnly) {
+          return {
+            success: false,
+            error: `Failed to install catalog skill "${spec.slug}"`,
+          };
+        }
         log.warn(
           { err, skillId: spec.slug },
           "Vellum catalog install failed, falling back to community registry",
         );
       }
 
+    if (spec.catalogOnly) {
+      return {
+        success: false,
+        error: `Skill "${spec.slug}" not found in the Vellum catalog`,
+      };
+    }
+
     // skills.sh install path: route here when origin is explicitly "skillssh"
     // or when the slug looks like a skills.sh multi-segment format (owner/repo/skill)
     if (
@@ -1104,45 +1189,44 @@ export async function installSkill(spec: {
       (spec.origin !== "clawhub" && looksLikeSkillsShSlug(spec.slug))
     ) {
       const resolved = resolveSkillSource(spec.slug);
+      // Default `overwrite` to true at the handler boundary to preserve
+      // pre-existing HTTP API behaviour (same rationale as the catalog
+      // install path above).
       await installExternalSkill(
         resolved.owner,
         resolved.repo,
         resolved.skillSlug,
-        true /* overwrite */,
+        spec.overwrite ?? true,
         resolved.ref ?? spec.version,
         spec.contactId,
       );
 
-      const skillDir = join(getWorkspaceSkillsDir(), resolved.skillSlug);
-      postInstallSkill(resolved.skillSlug, skillDir);
+      postInstallSkill(resolved.skillSlug);
       return { success: true, skillId: resolved.skillSlug };
     }
 
     // Install from clawhub (community)
-    const result = await clawhubInstall(spec.slug, {
-      version: spec.version,
-      contactId: spec.contactId,
-    });
-    if (!result.success) {
-      return { success: false, error: result.error ?? "Unknown error" };
-    }
-    const rawId = result.skillName ?? spec.slug;
-    const skillId = rawId.includes("/") ? rawId.split("/").pop()! : rawId;
-
-    // clawhubInstall uses the clawhub CLI which doesn't handle bun install
-    // or SKILLS.md indexing, so we do those here before post-install.
-    const skillDir = join(getWorkspaceSkillsDir(), skillId);
-    if (existsSync(join(skillDir, "package.json"))) {
-      const bunPath = `${homedir()}/.bun/bin`;
-      execSync("bun install", {
-        cwd: skillDir,
-        stdio: "inherit",
-        env: { ...process.env, PATH: `${bunPath}:${process.env.PATH}` },
+    let skillId = spec.slug;
+    const clawhubProjectRoot = createSkillInstallStagingDir();
+    try {
+      const result = await clawhubInstall(spec.slug, {
+        version: spec.version,
+        contactId: spec.contactId,
+        projectRoot: clawhubProjectRoot,
       });
+      if (!result.success) {
+        return { success: false, error: result.error ?? "Unknown error" };
+      }
+      skillId = result.skillId;
+
+      const stagedSkillDir = result.skillDir;
+      installSkillDependenciesIfPresent(stagedSkillDir);
+      commitStagedSkillInstall(skillId, stagedSkillDir);
+    } finally {
+      rmSync(clawhubProjectRoot, { recursive: true, force: true });
     }
-    upsertSkillsIndex(skillId);
 
-    postInstallSkill(skillId, skillDir);
+    postInstallSkill(skillId);
     return { success: true, skillId };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1184,11 +1268,6 @@ export async function uninstallSkill(
         return { success: false, error: "Skill not found" };
       }
       rmSync(skillDir, { recursive: true });
-      try {
-        removeSkillsIndexEntry(skillId);
-      } catch {
-        /* best effort */
-      }
       // Best-effort cleanup of capability memory for uninstalled skill
       // (managed path handles this internally via deleteManagedSkill)
       deleteSkillCapabilityNode(skillId);
@@ -1209,6 +1288,8 @@ export async function uninstallSkill(
       state: "uninstalled",
     });
 
+    refreshSkillCapabilityMemories(getConfig());
+
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1250,6 +1331,7 @@ export async function checkSkillUpdates(): Promise<
 
 export async function searchSkills(
   query: string,
+  limit: number = 25,
 ): Promise<
   | { success: true; skills: SlimSkillResponse[] }
   | { success: false; error: string }
@@ -1290,8 +1372,8 @@ export async function searchSkills(
 
     // Search both community registries in parallel (non-fatal on failure)
     const [clawhubResult, skillsshResult] = await Promise.allSettled([
-      clawhubSearch(query),
-      searchSkillsRegistry(query, 25),
+      clawhubSearch(query, { limit }),
+      searchSkillsRegistry(query, limit),
     ]);
 
     let clawhubSkills: SlimSkillResponse[] = [];
@@ -1467,7 +1549,9 @@ export async function draftSkill(params: {
           try {
             const prompt = [
               "Given the following skill body text, generate metadata for a managed skill.",
-              `Return ONLY valid JSON with these fields: ${missing.join(", ")}.`,
+              `Return ONLY valid JSON with these fields: ${missing.join(
+                ", ",
+              )}.`,
               "Field descriptions:",
               "- skillId: a short kebab-case identifier (lowercase, alphanumeric + hyphens/dots/underscores, max 50 chars, must start with a letter or digit)",
               "- name: a human-readable name (max 100 chars)",
@@ -1630,9 +1714,7 @@ export async function createSkill(
       );
     }
 
-    seedSkillGraphNodes();
-    maybeSeedMemoryV2Skills(getConfig());
-    void seedUninstalledCatalogSkillMemories().catch(() => {});
+    refreshSkillCapabilityMemories(getConfig());
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);

package/src/daemon/history-repair.ts

@@ -68,11 +68,14 @@ export function repairHistory(messages: Message[]): RepairResult {
         }
       }
 
-      // Ensure every server_tool_use has a paired web_search_tool_result
-      // in the same assistant message (handles interrupted streams).
-      // Synthetic results are inserted IMMEDIATELY AFTER their corresponding
-      // server_tool_use block — not appended to the end — so that
-      // ensureToolPairing's split at tool_use boundaries cannot separate them.
+      // Pair server-side tool blocks within the same assistant message.
+      // Server tools (e.g. web_search) emit server_tool_use + matching
+      // web_search_tool_result. Either side can go missing — the synthetic
+      // result is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
+      // appended to the end) so ensureToolPairing's split at tool_use
+      // boundaries cannot separate the pair. An orphan
+      // web_search_tool_result (no preceding server_tool_use) is downgraded
+      // to text — Anthropic rejects the request otherwise.
       const serverToolIds = new Set(
         cleanedContent
           .filter(
@@ -91,11 +94,35 @@ export function repairHistory(messages: Message[]): RepairResult {
           orphanedServerIds.add(id);
         }
       }
+      const orphanedWebSearchResultIds = new Set<string>();
+      for (const id of matchedServerIds) {
+        if (!serverToolIds.has(id)) {
+          orphanedWebSearchResultIds.add(id);
+        }
+      }
 
       let repairedContent: ContentBlock[];
-      if (orphanedServerIds.size > 0) {
+      if (orphanedServerIds.size > 0 || orphanedWebSearchResultIds.size > 0) {
         repairedContent = [];
         for (const block of cleanedContent) {
+          if (
+            block.type === "web_search_tool_result" &&
+            orphanedWebSearchResultIds.has(
+              (block as { tool_use_id: string }).tool_use_id,
+            )
+          ) {
+            repairedContent.push(
+              downgradeResult(
+                block as {
+                  type: "web_search_tool_result";
+                  tool_use_id: string;
+                  content: unknown;
+                },
+              ),
+            );
+            stats.orphanToolResultsDowngraded++;
+            continue;
+          }
           repairedContent.push(block);
           if (
             block.type === "server_tool_use" &&
@@ -291,9 +318,36 @@ function downgradeResult(tr: {
   content?: unknown;
 }): ContentBlock {
   const content =
-    tr.type === "tool_result" ? tr.content : "[web search result]"; // guard:allow-tool-result-only — distinguishes content format between the two types
+    tr.type === "tool_result" ? tr.content : formatWebSearchContent(tr.content); // guard:allow-tool-result-only — distinguishes content format between the two types
   return {
     type: "text",
     text: `[orphaned ${tr.type} for ${tr.tool_use_id}]: ${content}`,
   };
 }
+
+function formatWebSearchContent(content: unknown): string {
+  if (Array.isArray(content)) {
+    const entries: string[] = [];
+    for (const r of content) {
+      if (
+        typeof r !== "object" ||
+        r == null ||
+        (r as { type?: string }).type !== "web_search_result"
+      ) {
+        continue;
+      }
+      const title =
+        typeof (r as { title?: unknown }).title === "string"
+          ? (r as { title: string }).title
+          : "(untitled)";
+      const url =
+        typeof (r as { url?: unknown }).url === "string"
+          ? (r as { url: string }).url
+          : "";
+      const idx = entries.length + 1;
+      entries.push(url ? `${idx}. ${title}\n   ${url}` : `${idx}. ${title}`);
+    }
+    if (entries.length > 0) return entries.join("\n");
+  }
+  return "results unavailable";
+}