mulmoclaude 0.5.2 → 0.6.0

package/server/api/routes/sessions.ts

@@ -1,15 +1,21 @@
 import { Router, Request, Response } from "express";
 import { realpathSync } from "fs";
 import { readdir, stat } from "fs/promises";
-import { readTextSafe } from "../../utils/files/safe.js";
+import { readTextSafe, resolveWithinRoot } from "../../utils/files/safe.js";
 import path from "path";
 import { workspacePath } from "../../workspace/workspace.js";
 import { WORKSPACE_PATHS } from "../../workspace/paths.js";
-import { readSessionMeta as readSessionMetaIO, readSessionJsonl, sessionJsonlAbsPath, sessionMetaAbsPath } from "../../utils/files/session-io.js";
-import { readManifest } from "../../workspace/chat-index/indexer.js";
-import { resolveWithinRoot } from "../../utils/files/safe.js";
+import {
+  readSessionMeta as readSessionMetaIO,
+  readSessionJsonl,
+  sessionJsonlAbsPath,
+  sessionMetaAbsPath,
+  updateIsBookmarked,
+  deleteSessionFiles,
+} from "../../utils/files/session-io.js";
+import { readManifest, removeSessionFromIndex } from "../../workspace/chat-index/indexer.js";
 import type { ChatIndexEntry } from "../../workspace/chat-index/types.js";
-import { markRead, getSession } from "../../events/session-store/index.js";
+import { markRead, getSession, evictSession, publishSessionsChanged } from "../../events/session-store/index.js";
 import { notFound } from "../../utils/httpError.js";
 import { API_ROUTES } from "../../../src/config/apiRoutes.js";
 import { EVENT_TYPES } from "../../../src/types/events.js";
@@ -25,6 +31,7 @@ interface SessionMeta {
   startedAt: string;
   firstUserMessage?: string;
   hasUnread?: boolean;
+  isBookmarked?: boolean;
   origin?: SessionOrigin;
 }
 
@@ -66,6 +73,9 @@ export interface SessionSummary {
   keywords?: string[];
   // Where this session originated (#486). Missing = "human".
   origin?: SessionOrigin;
+  // User-toggled bookmark — surfaced in the history panel as a
+  // dedicated filter chip and a green role-icon tint.
+  isBookmarked?: boolean;
   // Live state from the in-memory session store. Absent when the
   // session has no active entry in the store (i.e. idle / historical).
   isRunning?: boolean;
@@ -97,73 +107,98 @@ const router = Router();
 // SESSIONS_LIST_WINDOW_DAYS to override (0 = no cutoff).
 const WINDOW_MS = env.sessionsListWindowDays * ONE_DAY_MS;
 
+interface SessionRowContext {
+  chatDir: string;
+  cutoff: number;
+  indexById: Map<string, ChatIndexEntry>;
+}
+
+interface SessionRow {
+  summary: SessionSummary;
+  changeMs: number;
+}
+
+// Build a SessionSummary from the gathered inputs. Conditional spreads
+// honour the server tsconfig's `exactOptionalPropertyTypes`; that's
+// why each optional field is set with `if (… !== undefined)` rather
+// than spread into the object literal directly.
+function buildSessionSummary(
+  sessionId: string,
+  meta: SessionMeta,
+  indexEntry: ChatIndexEntry | undefined,
+  fileStat: { mtimeMs: number },
+  live: ReturnType<typeof getSession>,
+): SessionSummary {
+  // Prefer AI title → meta.firstUserMessage → empty.
+  const preview = indexEntry?.title ?? meta.firstUserMessage ?? "";
+  const summary: SessionSummary = {
+    id: sessionId,
+    roleId: meta.roleId,
+    startedAt: meta.startedAt,
+    updatedAt: new Date(fileStat.mtimeMs).toISOString(),
+    preview,
+    hasUnread: live?.hasUnread ?? meta.hasUnread ?? false,
+  };
+  if (meta.origin) summary.origin = meta.origin;
+  if (meta.isBookmarked) summary.isBookmarked = true;
+  if (indexEntry?.summary !== undefined) summary.summary = indexEntry.summary;
+  if (indexEntry?.keywords !== undefined) summary.keywords = indexEntry.keywords;
+  if (live) {
+    // Background generations (image/audio/movie) keep the session
+    // "busy" even when the agent turn has ended, so the sidebar
+    // indicator stays lit across view navigation.
+    summary.isRunning = live.isRunning || Object.keys(live.pendingGenerations).length > 0;
+    summary.statusMessage = live.statusMessage;
+  }
+  return summary;
+}
+
+// Load one session's row, or null when the session should be skipped
+// (cutoff window, missing meta, any I/O error). The `metaMtimeMs`
+// fallback lets a brand-new session contribute 0 to its changeMs
+// instead of crashing the whole listing.
+async function loadSessionRow(sessionId: string, ctx: SessionRowContext): Promise<SessionRow | null> {
+  try {
+    // stat only — no readFile on .jsonl content
+    const fileStat = await stat(sessionJsonlAbsPath(sessionId));
+    if (ctx.cutoff > 0 && fileStat.mtimeMs < ctx.cutoff) return null;
+
+    const meta = await readSessionMeta(ctx.chatDir, sessionId);
+    if (!meta) return null;
+
+    // The meta sidecar bumps its mtime on hasUnread / origin writes —
+    // feed it into changeMs so cursor-based refetches pick up drains
+    // of background generations (which only touch meta, not the
+    // jsonl).
+    const metaMtimeMs = await stat(sessionMetaAbsPath(sessionId))
+      .then((stats) => stats.mtimeMs)
+      .catch(() => 0);
+
+    const indexEntry = ctx.indexById.get(sessionId);
+    const live = getSession(sessionId);
+    return {
+      summary: buildSessionSummary(sessionId, meta, indexEntry, fileStat, live),
+      changeMs: sessionChangeMs(fileStat.mtimeMs, indexEntry?.indexedAt, metaMtimeMs),
+    };
+  } catch {
+    return null;
+  }
+}
+
 // Read the full session list off disk. Each row carries its
 // `changeMs` — the later of the jsonl mtime and the chat-index
 // `indexedAt` — so the handler can filter against `?since=` and
 // compute the new cursor without re-statting anything.
-export async function loadAllSessions(): Promise<{ summary: SessionSummary; changeMs: number }[]> {
+export async function loadAllSessions(): Promise<SessionRow[]> {
   const chatDir = WORKSPACE_PATHS.chat;
   const manifest = await readManifest(workspacePath);
   const indexById = new Map<string, ChatIndexEntry>(manifest.entries.map((entry) => [entry.id, entry]));
   const cutoff = WINDOW_MS > 0 ? Date.now() - WINDOW_MS : 0;
+  const ctx: SessionRowContext = { chatDir, cutoff, indexById };
 
   const files = (await readdir(chatDir)).filter((fileName) => fileName.endsWith(".jsonl"));
-  const rows = await Promise.all(
-    files.map(async (file) => {
-      const sessionId = file.replace(".jsonl", "");
-      try {
-        // stat only — no readFile on .jsonl content
-        const fileStat = await stat(sessionJsonlAbsPath(sessionId));
-        if (cutoff > 0 && fileStat.mtimeMs < cutoff) return null;
-
-        const meta = await readSessionMeta(chatDir, sessionId);
-        if (!meta) return null;
-
-        // The meta sidecar bumps its mtime on hasUnread / origin
-        // writes — feed it into changeMs so cursor-based refetches
-        // pick up drains of background generations (which only touch
-        // meta, not the jsonl). Missing stat (brand-new session
-        // before its first meta write) contributes 0.
-        const metaMtimeMs = await stat(sessionMetaAbsPath(sessionId))
-          .then((stats) => stats.mtimeMs)
-          .catch(() => 0);
-
-        const indexEntry = indexById.get(sessionId);
-        // Prefer AI title → meta.firstUserMessage → empty.
-        // `summary` and `keywords` are spread conditionally
-        // to respect the server tsconfig's
-        // exactOptionalPropertyTypes.
-        const preview = indexEntry?.title ?? meta.firstUserMessage ?? "";
-
-        const live = getSession(sessionId);
-        const summary: SessionSummary = {
-          id: sessionId,
-          roleId: meta.roleId,
-          startedAt: meta.startedAt,
-          updatedAt: new Date(fileStat.mtimeMs).toISOString(),
-          preview,
-          hasUnread: live?.hasUnread ?? meta.hasUnread ?? false,
-        };
-        if (meta.origin) summary.origin = meta.origin;
-        if (indexEntry?.summary !== undefined) summary.summary = indexEntry.summary;
-        if (indexEntry?.keywords !== undefined) summary.keywords = indexEntry.keywords;
-        if (live) {
-          // Background generations (image/audio/movie) keep the session
-          // "busy" even when the agent turn has ended, so the sidebar
-          // indicator stays lit across view navigation.
-          summary.isRunning = live.isRunning || Object.keys(live.pendingGenerations).length > 0;
-          summary.statusMessage = live.statusMessage;
-        }
-        return {
-          summary,
-          changeMs: sessionChangeMs(fileStat.mtimeMs, indexEntry?.indexedAt, metaMtimeMs),
-        };
-      } catch {
-        return null;
-      }
-    }),
-  );
-  return rows.filter((row): row is { summary: SessionSummary; changeMs: number } => row !== null);
+  const rows = await Promise.all(files.map((file) => loadSessionRow(file.replace(".jsonl", ""), ctx)));
+  return rows.filter((row): row is SessionRow => row !== null);
 }
 
 router.get(API_ROUTES.sessions.list, async (req: Request<object, SessionsResponse, object, SessionsQuery>, res: Response<SessionsResponse>) => {
@@ -211,6 +246,79 @@ interface SessionErrorResponse {
   error: string;
 }
 
+// Narrow type predicate for the presentMulmoScript tool-result shape
+// the enrichment helper inspects. Returning `entry is …` lets the
+// caller drop the redundant nested checks once the predicate passes.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isPresentMulmoScriptToolResult(entry: any): entry is {
+  source: "tool";
+  type: string;
+  result: { toolName: "presentMulmoScript"; data: { filePath: string } & Record<string, unknown> };
+} & Record<string, unknown> {
+  return (
+    entry?.source === "tool" &&
+    entry?.type === EVENT_TYPES.toolResult &&
+    entry?.result?.toolName === "presentMulmoScript" &&
+    typeof entry?.result?.data?.filePath === "string"
+  );
+}
+
+// Re-read the MulmoScript JSON pointed at by `entry.result.data.filePath`
+// and merge it into a copy of the entry. Returns the original entry on
+// any failure (missing file, traversal escape, parse error, absolute
+// path) so the detail route never breaks because of a single rotted
+// link. Path-traversal guard is realpath-based — see
+// resolveWithinRoot for why.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function enrichWithMulmoScript(entry: any): Promise<any> {
+  try {
+    const storiesDir = path.resolve(WORKSPACE_PATHS.stories);
+    let storiesReal: string;
+    try {
+      storiesReal = realpathSync(storiesDir);
+    } catch {
+      return entry;
+    }
+    const scriptRelPath: string = entry.result.data.filePath;
+    if (path.isAbsolute(scriptRelPath)) return entry;
+    const relFromStories = scriptRelPath.startsWith("stories/") ? scriptRelPath.slice("stories/".length) : scriptRelPath;
+    const scriptPath = resolveWithinRoot(storiesReal, relFromStories);
+    if (!scriptPath) return entry;
+    const scriptJson = (await readTextSafe(scriptPath)) ?? "";
+    return {
+      ...entry,
+      result: {
+        ...entry.result,
+        data: {
+          ...entry.result.data,
+          script: JSON.parse(scriptJson),
+        },
+      },
+    };
+  } catch {
+    return entry;
+  }
+}
+
+// Parse one JSONL line into a session entry, applying the legacy-meta
+// skip and the presentMulmoScript enrichment in one place. Returns
+// null when the line should not appear in the response (parse error
+// or legacy meta).
+async function parseSessionEntry(line: string): Promise<unknown> {
+  let entry: unknown;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  // Skip legacy metadata entries now stored in .json
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const typed = entry as any;
+  if (typed?.type === EVENT_TYPES.sessionMeta || typed?.type === EVENT_TYPES.claudeSessionId) return null;
+  if (isPresentMulmoScriptToolResult(typed)) return enrichWithMulmoScript(typed);
+  return typed;
+}
+
 router.get(API_ROUTES.sessions.detail, async (req: Request<SessionIdParams>, res: Response<unknown[] | SessionErrorResponse>) => {
   const { id: sessionId } = req.params;
   const chatDir = WORKSPACE_PATHS.chat;
@@ -223,65 +331,7 @@ router.get(API_ROUTES.sessions.detail, async (req: Request<SessionIdParams>, res
       notFound(res, `Session ${sessionId} not found`);
       return;
     }
-    const entries = (
-      await Promise.all(
-        content
-          .split("\n")
-          .filter(Boolean)
-          .map(async (line) => {
-            try {
-              const entry = JSON.parse(line);
-              // Skip legacy metadata entries now stored in .json
-              if (entry.type === EVENT_TYPES.sessionMeta || entry.type === EVENT_TYPES.claudeSessionId) return null;
-              // For presentMulmoScript results, re-read the script from disk
-              if (
-                entry.source === "tool" &&
-                entry.type === EVENT_TYPES.toolResult &&
-                entry.result?.toolName === "presentMulmoScript" &&
-                entry.result?.data?.filePath
-              ) {
-                try {
-                  // Realpath-based traversal check defeats symlink
-                  // escapes — see resolveWithinRoot in utils/fs.ts.
-                  // Resolve the stories dir's realpath so the
-                  // boundary check works even when stories/ itself
-                  // is a legitimate symlink to another disk.
-                  const storiesDir = path.resolve(WORKSPACE_PATHS.stories);
-                  let storiesReal: string;
-                  try {
-                    storiesReal = realpathSync(storiesDir);
-                  } catch {
-                    return entry;
-                  }
-                  const scriptRelPath: string = entry.result.data.filePath;
-                  if (path.isAbsolute(scriptRelPath)) return entry;
-                  // Strip optional "stories/" prefix so the
-                  // remainder is relative to storiesReal.
-                  const relFromStories = scriptRelPath.startsWith("stories/") ? scriptRelPath.slice("stories/".length) : scriptRelPath;
-                  const scriptPath = resolveWithinRoot(storiesReal, relFromStories);
-                  if (!scriptPath) return entry;
-                  const scriptJson = (await readTextSafe(scriptPath)) ?? "";
-                  return {
-                    ...entry,
-                    result: {
-                      ...entry.result,
-                      data: {
-                        ...entry.result.data,
-                        script: JSON.parse(scriptJson),
-                      },
-                    },
-                  };
-                } catch {
-                  // file missing — return original entry
-                }
-              }
-              return entry;
-            } catch {
-              return null;
-            }
-          }),
-      )
-    ).filter(Boolean);
+    const entries = (await Promise.all(content.split("\n").filter(Boolean).map(parseSessionEntry))).filter(Boolean);
     // Prepend metadata as session_meta entry for the frontend
     const result = meta ? [{ type: EVENT_TYPES.sessionMeta, ...meta }, ...entries] : entries;
     log.info("sessions", "detail: ok", { sessionId, entries: result.length });
@@ -302,4 +352,67 @@ router.post(API_ROUTES.sessions.markRead, async (req: Request<SessionIdParams>,
   res.json({ ok: true });
 });
 
+// Toggle the user-set bookmark flag on a session's meta sidecar.
+router.post(
+  API_ROUTES.sessions.bookmark,
+  async (
+    req: Request<SessionIdParams, { ok: boolean } | SessionErrorResponse, { bookmarked: boolean }>,
+    res: Response<{ ok: boolean } | SessionErrorResponse>,
+  ) => {
+    const { id: sessionId } = req.params;
+    const bookmarked = Boolean(req.body?.bookmarked);
+    log.info("sessions", "bookmark: start", { sessionId, bookmarked });
+    try {
+      await updateIsBookmarked(sessionId, bookmarked);
+      // Meta-mtime bumps on the write — cursor diff will pick up the
+      // change on the next refetch — but every other tab also needs
+      // to know to refetch right now.
+      publishSessionsChanged();
+      log.info("sessions", "bookmark: ok", { sessionId, bookmarked });
+      res.json({ ok: true });
+    } catch (err) {
+      log.error("sessions", "bookmark: threw", { sessionId, error: errorMessage(err) });
+      res.status(500).json({ error: "Failed to update bookmark" });
+    }
+  },
+);
+
+// Hard-delete a session: remove the jsonl, meta sidecar, AND the
+// chat-index per-session file + manifest entry, then evict the
+// in-memory store entry and broadcast `deletedIds` so every tab
+// prunes its caches.
+//
+// Order matters:
+//   1. Refuse if the session is currently running. The agent route
+//      (server/api/routes/agent.ts) writes via `appendSessionLine` /
+//      `endRun`; deleting the files out from under a live run would
+//      either resurrect them or corrupt mid-stream state. Caller
+//      should cancel first, then retry the delete.
+//   2. Delete the on-disk artifacts (jsonl + meta + index entry +
+//      manifest prune). If any of these throw we abort BEFORE
+//      evicting / broadcasting, so clients don't see "session gone"
+//      while the file lingers.
+//   3. Only after disk is clean do we evict from the store and fire
+//      `notifySessionsChanged({ deletedIds })`. Now the broadcast is
+//      a truthful statement.
+router.delete(API_ROUTES.sessions.detail, async (req: Request<SessionIdParams>, res: Response<{ ok: boolean } | SessionErrorResponse>) => {
+  const { id: sessionId } = req.params;
+  log.info("sessions", "delete: start", { sessionId });
+  if (getSession(sessionId)?.isRunning) {
+    log.warn("sessions", "delete: refused — session running", { sessionId });
+    res.status(409).json({ error: "Session is running. Cancel the run before deleting." });
+    return;
+  }
+  try {
+    await deleteSessionFiles(sessionId);
+    await removeSessionFromIndex(workspacePath, sessionId);
+    evictSession(sessionId);
+    log.info("sessions", "delete: ok", { sessionId });
+    res.json({ ok: true });
+  } catch (err) {
+    log.error("sessions", "delete: threw", { sessionId, error: errorMessage(err) });
+    res.status(500).json({ error: "Failed to delete session" });
+  }
+});
+
 export default router;

package/server/api/routes/skills.ts

@@ -17,6 +17,7 @@ import { deleteProjectSkill, discoverSkills, saveProjectSkill, updateProjectSkil
 import type { Skill, SkillSummary } from "../../workspace/skills/index.js";
 import { workspacePath } from "../../workspace/workspace.js";
 import { API_ROUTES } from "../../../src/config/apiRoutes.js";
+import { bindRoute } from "../../utils/router.js";
 import { log } from "../../system/logger/index.js";
 import { refreshScheduledSkills } from "../../workspace/skills/scheduler.js";
 import { logBackgroundError } from "../../utils/logBackgroundError.js";
@@ -52,7 +53,7 @@ interface DeleteSkillResponse {
   name: string;
 }
 
-router.get(API_ROUTES.skills.list, async (_req: Request, res: Response<SkillsListResponse>) => {
+bindRoute(router, API_ROUTES.skills.list, async (_req: Request, res: Response<SkillsListResponse>) => {
   const skills = await discoverSkills({ workspaceRoot: workspacePath });
   log.info("skills", "list: ok", { count: skills.length });
   res.json({
@@ -64,7 +65,7 @@ router.get(API_ROUTES.skills.list, async (_req: Request, res: Response<SkillsLis
   });
 });
 
-router.get(API_ROUTES.skills.detail, async (req: Request<{ name: string }>, res: Response<SkillDetailResponse | ErrorResponse>) => {
+bindRoute(router, API_ROUTES.skills.detail, async (req: Request<{ name: string }>, res: Response<SkillDetailResponse | ErrorResponse>) => {
   log.info("skills", "detail: start", { name: req.params.name });
   const skills = await discoverSkills({ workspaceRoot: workspacePath });
   const skill = skills.find((candidate) => candidate.name === req.params.name);
@@ -76,7 +77,7 @@ router.get(API_ROUTES.skills.detail, async (req: Request<{ name: string }>, res:
   res.json({ skill });
 });
 
-router.post(API_ROUTES.skills.create, async (req: Request<object, unknown, SaveSkillBody>, res: Response<SaveSkillResponse | ErrorResponse>) => {
+bindRoute(router, API_ROUTES.skills.create, async (req: Request<object, unknown, SaveSkillBody>, res: Response<SaveSkillResponse | ErrorResponse>) => {
   const { name, description, body } = req.body ?? {};
   log.info("skills", "create: start", { name: typeof name === "string" ? name : undefined });
   if (typeof name !== "string") {
@@ -135,54 +136,58 @@ interface UpdateSkillResponse {
   path: string;
 }
 
-router.put(API_ROUTES.skills.update, async (req: Request<{ name: string }, unknown, UpdateSkillBody>, res: Response<UpdateSkillResponse | ErrorResponse>) => {
-  const { name } = req.params;
-  const { description, body } = req.body ?? {};
-  log.info("skills", "update: start", { name });
-  if (typeof description !== "string") {
-    log.warn("skills", "update: invalid description", { name });
-    badRequest(res, "description must be a string");
-    return;
-  }
-  if (typeof body !== "string") {
-    log.warn("skills", "update: invalid body", { name });
-    badRequest(res, "body must be a string");
-    return;
-  }
-  const result = await updateProjectSkill({
-    workspaceRoot: workspacePath,
-    name,
-    description,
-    body,
-  });
-  if (result.kind === "updated") {
-    log.info("skills", "updated", { name });
-    refreshScheduledSkills().catch(logBackgroundError("skills"));
-    res.json({ updated: true, path: result.path });
-    return;
-  }
-  if (result.kind === "invalid-slug") {
-    log.warn("skills", "update: invalid slug", { slug: result.slug });
-    badRequest(res, `invalid slug: "${result.slug}"`);
-    return;
-  }
-  if (result.kind === "missing-field") {
-    log.warn("skills", "update: missing field", { name, field: result.field });
-    badRequest(res, `${result.field} must be a non-empty string`);
-    return;
-  }
-  if (result.kind === "user-scope") {
-    log.warn("skills", "update: user scope refused", { name: result.name });
-    forbidden(res, `cannot update user-scope skill "${result.name}" — only project-scope skills are writable.`);
-    return;
-  }
-  if (result.kind === "not-found") {
-    log.warn("skills", "update: not found", { name: result.name });
-    notFound(res, `skill not found: ${result.name}`);
-  }
-});
-
-router.delete(API_ROUTES.skills.remove, async (req: Request<{ name: string }>, res: Response<DeleteSkillResponse | ErrorResponse>) => {
+bindRoute(
+  router,
+  API_ROUTES.skills.update,
+  async (req: Request<{ name: string }, unknown, UpdateSkillBody>, res: Response<UpdateSkillResponse | ErrorResponse>) => {
+    const { name } = req.params;
+    const { description, body } = req.body ?? {};
+    log.info("skills", "update: start", { name });
+    if (typeof description !== "string") {
+      log.warn("skills", "update: invalid description", { name });
+      badRequest(res, "description must be a string");
+      return;
+    }
+    if (typeof body !== "string") {
+      log.warn("skills", "update: invalid body", { name });
+      badRequest(res, "body must be a string");
+      return;
+    }
+    const result = await updateProjectSkill({
+      workspaceRoot: workspacePath,
+      name,
+      description,
+      body,
+    });
+    if (result.kind === "updated") {
+      log.info("skills", "updated", { name });
+      refreshScheduledSkills().catch(logBackgroundError("skills"));
+      res.json({ updated: true, path: result.path });
+      return;
+    }
+    if (result.kind === "invalid-slug") {
+      log.warn("skills", "update: invalid slug", { slug: result.slug });
+      badRequest(res, `invalid slug: "${result.slug}"`);
+      return;
+    }
+    if (result.kind === "missing-field") {
+      log.warn("skills", "update: missing field", { name, field: result.field });
+      badRequest(res, `${result.field} must be a non-empty string`);
+      return;
+    }
+    if (result.kind === "user-scope") {
+      log.warn("skills", "update: user scope refused", { name: result.name });
+      forbidden(res, `cannot update user-scope skill "${result.name}" — only project-scope skills are writable.`);
+      return;
+    }
+    if (result.kind === "not-found") {
+      log.warn("skills", "update: not found", { name: result.name });
+      notFound(res, `skill not found: ${result.name}`);
+    }
+  },
+);
+
+bindRoute(router, API_ROUTES.skills.remove, async (req: Request<{ name: string }>, res: Response<DeleteSkillResponse | ErrorResponse>) => {
   log.info("skills", "delete: start", { name: req.params.name });
   const result = await deleteProjectSkill({
     workspaceRoot: workspacePath,