mulmoclaude 0.6.2 → 0.6.4

package/server/workspace/skills/external/install.ts

@@ -0,0 +1,417 @@
+// Install / uninstall of an external-skill repo into the catalog
+// (#1383 / #1335 PR-C).
+//
+// Pipeline for install:
+//   1. validate URL → derive repoId
+//   2. clone (or refresh) the scratch dir via `cloneOrUpdate`
+//   3. discover SKILL.md files inside the (optionally subpath-
+//      scoped) tree
+//   4. copy each discovered skill folder into
+//      `<workspace>/data/skills/catalog/external/<repoId>/`
+//   5. write `.source.json` recording url / subpath / ref / sha / time
+//
+// Uninstall is the inverse: blow away the catalog dir for `repoId`
+// and the corresponding scratch clone. Active copies (anything the
+// user already Starred into `.claude/skills/`) are NOT touched —
+// star = fork, so users keep what they activated even after the
+// upstream repo is removed.
+
+import { copyFile, lstat, mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+import path from "node:path";
+
+import { workspacePath } from "../../workspace.js";
+import { WORKSPACE_DIRS } from "../../paths.js";
+import { parseSkillFrontmatter } from "../parser.js";
+import { log } from "../../../system/logger/index.js";
+import { errorMessage } from "../../../utils/errors.js";
+import { writeFileAtomic } from "../../../utils/files/index.js";
+import { cloneOrUpdate, defaultCacheRoot, type CloneDeps, type CloneResult } from "./clone.js";
+import { canonicalRepoUrl, deriveRepoId, safeRepoId, safeSkillFolder, sanitiseSubpath, urlCacheKey } from "./id.js";
+
+const SOURCE_METADATA_FILE = ".source.json";
+
+export interface InstallRepoOptions {
+  url: string;
+  subpath?: string;
+  ref?: string;
+}
+
+export interface InstallResult {
+  repoId: string;
+  url: string;
+  subpath?: string;
+  ref?: string;
+  sha: string;
+  installedAt: string;
+  /** Number of SKILL.md files discovered + copied into the catalog
+   *  dir. Zero is technically valid (an empty repo) but suspicious;
+   *  callers may surface it as a warning. */
+  skillCount: number;
+}
+
+export interface ExternalInstallOptions extends CloneDeps {
+  /** Override the workspace root. Default: live `workspacePath`. */
+  workspaceRoot?: string;
+}
+
+interface DiscoveredSkill {
+  /** Folder name as it appears in the catalog dir. `"."` indicates
+   *  the SKILL.md lives at the repo root (single-skill repo). */
+  folder: string;
+  /** Absolute source path of the skill dir inside the scratch
+   *  clone. */
+  sourceDir: string;
+}
+
+async function isDirectory(absPath: string): Promise<boolean> {
+  try {
+    return (await stat(absPath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// `lstat`-based checks for the UNTRUSTED scratch-clone tree. A
+// malicious external repo can ship symlinks (`SKILL.md` →
+// `/etc/passwd`, a skill dir → `/`); `stat` follows them, so
+// discovery/copy would read or duplicate host files. These reject
+// symlinks (and anything that isn't a plain dir / plain file). Our
+// own catalog dirs still use the `stat`-based helpers above.
+async function isRealDirectory(absPath: string): Promise<boolean> {
+  try {
+    return (await lstat(absPath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function isRealFile(absPath: string): Promise<boolean> {
+  try {
+    return (await lstat(absPath)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+async function hasParseableSkill(skillDir: string): Promise<boolean> {
+  const skillMd = path.join(skillDir, "SKILL.md");
+  if (!(await isRealFile(skillMd))) return false;
+  try {
+    const raw = await readFile(skillMd, "utf-8");
+    return parseSkillFrontmatter(raw) !== null;
+  } catch {
+    return false;
+  }
+}
+
+/** Discovery rules:
+ *   - `subpath` given → glob `<scratch>/<subpath>/&zwj;*&zwj;/SKILL.md`,
+ *     one level deep.
+ *   - Else → first try `<scratch>/SKILL.md` (single-skill-at-root).
+ *           If absent, glob `<scratch>/&zwj;*&zwj;/SKILL.md` (multi-skill
+ *           without a `subpath` declaration). */
+async function discoverSkills(cacheDir: string, subpath: string | undefined): Promise<DiscoveredSkill[]> {
+  if (subpath) {
+    const scanRoot = path.join(cacheDir, subpath);
+    if (!(await isRealDirectory(scanRoot))) return [];
+    return await scanOneLevel(scanRoot);
+  }
+  if (await hasParseableSkill(cacheDir)) {
+    return [{ folder: ".", sourceDir: cacheDir }];
+  }
+  return await scanOneLevel(cacheDir);
+}
+
+async function scanOneLevel(scanRoot: string): Promise<DiscoveredSkill[]> {
+  let entries: string[];
+  try {
+    entries = await readdir(scanRoot);
+  } catch {
+    return [];
+  }
+  const out: DiscoveredSkill[] = [];
+  for (const entry of entries) {
+    // Same folder-name rule the read/star side uses (`safeSkillFolder`)
+    // so anything we accept here stays listable + addressable. Skips
+    // hidden / `.` / `..` / separator-bearing names too.
+    const folder = safeSkillFolder(entry);
+    if (folder === null) continue;
+    const candidate = path.join(scanRoot, folder);
+    if (!(await isRealDirectory(candidate))) continue;
+    if (!(await hasParseableSkill(candidate))) continue;
+    out.push({ folder, sourceDir: candidate });
+  }
+  // Stable order for deterministic test output.
+  out.sort((left, right) => left.folder.localeCompare(right.folder));
+  return out;
+}
+
+function catalogExternalRoot(workspaceRoot: string): string {
+  return path.join(workspaceRoot, WORKSPACE_DIRS.skillsCatalog, "external");
+}
+
+interface ExtRepoPaths {
+  repoDir: string;
+  metadataPath: string;
+}
+
+function pathsForRepo(workspaceRoot: string, repoId: string): ExtRepoPaths {
+  const repoDir = path.join(catalogExternalRoot(workspaceRoot), repoId);
+  return { repoDir, metadataPath: path.join(repoDir, SOURCE_METADATA_FILE) };
+}
+
+async function writeMetadata(metadataPath: string, payload: Omit<InstallResult, "repoId" | "skillCount">): Promise<void> {
+  await writeFileAtomic(metadataPath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+
+/** Copy the discovered skill folder into the catalog under
+ *  `<external>/<repoId>/<targetFolder>/`. For single-skill-at-root
+ *  installs (`folder === "."`), the SKILL.md + siblings are copied
+ *  directly under the repo dir; nothing nests. */
+async function copyIntoCatalog(skill: DiscoveredSkill, repoDir: string): Promise<void> {
+  if (skill.folder === ".") {
+    await copyTreeNoSymlinks(skill.sourceDir, repoDir, [".git", SOURCE_METADATA_FILE]);
+    return;
+  }
+  await copyTreeNoSymlinks(skill.sourceDir, path.join(repoDir, skill.folder), [".git", SOURCE_METADATA_FILE]);
+}
+
+/** Recursively copy `srcDir` → `destDir`, copying ONLY plain dirs and
+ *  plain files. `Dirent` predicates use `lstat` semantics, so a
+ *  symlink entry is neither `isDirectory()` nor `isFile()` and is
+ *  silently skipped — an external repo can't smuggle a `SKILL.md` →
+ *  `/etc/passwd` (or a dir symlink) into the catalog / active layer.
+ *  `node:fs cp` with `recursive` would dereference such links. */
+async function copyTreeNoSymlinks(srcDir: string, destDir: string, skip: readonly string[]): Promise<void> {
+  await mkdir(destDir, { recursive: true });
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (skip.includes(entry.name)) continue;
+    const src = path.join(srcDir, entry.name);
+    const dst = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyTreeNoSymlinks(src, dst, skip);
+    } else if (entry.isFile()) {
+      await copyFile(src, dst);
+    }
+    // Symlinks / sockets / FIFOs intentionally skipped.
+  }
+}
+
+export type InstallExternalRepoResult =
+  | { kind: "installed"; detail: InstallResult }
+  | { kind: "invalid-url"; url: string }
+  | { kind: "invalid-subpath"; subpath: string }
+  | { kind: "no-skills"; repoId: string; sha: string }
+  | { kind: "id-collision"; repoId: string; existingUrl: string }
+  | { kind: "error"; reason: string };
+
+/** When `repoDir` already holds an install, return its recorded
+ *  canonical URL. `repoId` is a lossy punctuation-normalised slug, so
+ *  two different repos (`foo/a.b`, `foo/a-b`) can map to the same dir;
+ *  the canonical URL in `.source.json` is what actually identifies
+ *  the occupant. */
+async function existingCanonicalUrl(metadataPath: string): Promise<string | null> {
+  try {
+    const parsed = JSON.parse(await readFile(metadataPath, "utf-8")) as { url?: unknown };
+    return typeof parsed.url === "string" ? canonicalRepoUrl(parsed.url) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Install an external skill repo into the catalog. */
+export async function installExternalRepo(opts: InstallRepoOptions, deps: ExternalInstallOptions = {}): Promise<InstallExternalRepoResult> {
+  const repoId = deriveRepoId(opts.url);
+  if (!repoId) return { kind: "invalid-url", url: opts.url };
+
+  // Sanitise the subpath BEFORE it reaches `path.join` / the git
+  // sparse-checkout pattern. `path.join` collapses `..`, so an
+  // un-validated subpath could escape the scratch cache dir.
+  let subpath: string | undefined;
+  if (opts.subpath !== undefined) {
+    const clean = sanitiseSubpath(opts.subpath);
+    if (clean === null) return { kind: "invalid-subpath", subpath: opts.subpath };
+    subpath = clean;
+  }
+
+  const workspaceRoot = deps.workspaceRoot ?? workspacePath;
+  let clone: CloneResult;
+  try {
+    clone = await cloneOrUpdate({ url: opts.url, subpath, ref: opts.ref }, deps);
+  } catch (err) {
+    log.warn("skills-external", "git clone failed", { url: opts.url, error: errorMessage(err) });
+    return { kind: "error", reason: errorMessage(err, "git clone failed") };
+  }
+
+  const skills = await discoverSkills(clone.cacheDir, subpath);
+
+  // Bail BEFORE touching the catalog. Wiping + recreating + writing
+  // `.source.json` first meant a zero-skill fetch returned 422 while
+  // `GET /external/repos` still listed the repo and the previous
+  // catalog contents were already destroyed. Leaving a prior good
+  // install intact on a transient empty fetch is the safer outcome.
+  if (skills.length === 0) {
+    log.warn("skills-external", "install found no skills; catalog left untouched", { repoId, url: opts.url, subpath });
+    return { kind: "no-skills", repoId, sha: clone.sha };
+  }
+
+  const { repoDir, metadataPath } = pathsForRepo(workspaceRoot, repoId);
+
+  // Collision guard: `repoId` is a lossy slug. If this dir is already
+  // occupied by a DIFFERENT source repo (canonical URL mismatch),
+  // wiping it would silently destroy that repo's catalog + metadata.
+  // Refuse instead.
+  const occupant = await existingCanonicalUrl(metadataPath);
+  const incoming = canonicalRepoUrl(opts.url);
+  if (occupant && incoming && occupant !== incoming) {
+    log.warn("skills-external", "repoId collision; refusing to overwrite", { repoId, occupant, incoming });
+    return { kind: "id-collision", repoId, existingUrl: occupant };
+  }
+
+  // Wipe the previous catalog tree for this repoId so a re-install
+  // starts clean (removed skills don't linger). Cache dir is kept
+  // because we still need the checked-out tree to copy from.
+  await rm(repoDir, { recursive: true, force: true });
+  await mkdir(repoDir, { recursive: true });
+
+  for (const skill of skills) {
+    await copyIntoCatalog(skill, repoDir);
+  }
+
+  const installedAt = new Date().toISOString();
+  const detail: InstallResult = {
+    repoId,
+    url: opts.url,
+    subpath,
+    ref: opts.ref,
+    sha: clone.sha,
+    installedAt,
+    skillCount: skills.length,
+  };
+  await writeMetadata(metadataPath, {
+    url: opts.url,
+    subpath,
+    ref: opts.ref,
+    sha: clone.sha,
+    installedAt,
+  });
+
+  log.info("skills-external", "installed repo", { repoId, sha: clone.sha, skillCount: skills.length });
+  return { kind: "installed", detail };
+}
+
+export type UninstallResult = { kind: "uninstalled"; repoId: string } | { kind: "not-found"; repoId: string } | { kind: "invalid-repo-id"; repoId: string };
+
+/** Uninstall a repo: remove `data/skills/catalog/external/<repoId>/`
+ *  and the matching scratch clone keyed by the recorded URL. Active
+ *  copies under `.claude/skills/` are left in place. */
+export async function uninstallExternalRepo(repoIdRaw: string, deps: ExternalInstallOptions = {}): Promise<UninstallResult> {
+  // `repoIdRaw` is user-controlled (DELETE /external/repos/:repoId).
+  // Launder via the `path.basename` round-trip BEFORE composing any
+  // path — CodeQL only clears `js/path-injection` taint through that
+  // sanitiser, not a bare regex `.test()`.
+  const repoId = safeRepoId(repoIdRaw);
+  if (repoId === null) return { kind: "invalid-repo-id", repoId: repoIdRaw };
+  const workspaceRoot = deps.workspaceRoot ?? workspacePath;
+  const { repoDir, metadataPath } = pathsForRepo(workspaceRoot, repoId);
+  if (!(await isDirectory(repoDir))) return { kind: "not-found", repoId };
+
+  // Read URL from metadata BEFORE removing so we can also drop the
+  // scratch clone. Missing metadata isn't fatal — uninstall the
+  // catalog dir regardless.
+  let url: string | null = null;
+  try {
+    const raw = await readFile(metadataPath, "utf-8");
+    const parsed = JSON.parse(raw) as { url?: unknown };
+    const { url: parsedUrl } = parsed;
+    if (typeof parsedUrl === "string") url = parsedUrl;
+  } catch {
+    /* missing or corrupt metadata — proceed with catalog cleanup */
+  }
+
+  await rm(repoDir, { recursive: true, force: true });
+  if (url) {
+    const cacheRoot = deps.cacheRoot ?? defaultCacheRoot();
+    const cacheDir = path.join(cacheRoot, urlCacheKey(url));
+    await rm(cacheDir, { recursive: true, force: true }).catch((err) => {
+      log.warn("skills-external", "scratch clone cleanup failed", { repoId, cacheDir, error: errorMessage(err) });
+    });
+  }
+  log.info("skills-external", "uninstalled repo", { repoId });
+  return { kind: "uninstalled", repoId };
+}
+
+export interface InstalledRepo {
+  repoId: string;
+  url: string;
+  subpath?: string;
+  ref?: string;
+  sha: string;
+  installedAt: string;
+}
+
+interface RepoMetadataShape {
+  url: string;
+  subpath?: string;
+  ref?: string;
+  sha: string;
+  installedAt: string;
+}
+
+function isRepoMetadata(value: unknown): value is RepoMetadataShape {
+  if (!value || typeof value !== "object") return false;
+  const record = value as Record<string, unknown>;
+  if (typeof record.url !== "string") return false;
+  if (typeof record.sha !== "string") return false;
+  if (typeof record.installedAt !== "string") return false;
+  if (record.subpath !== undefined && typeof record.subpath !== "string") return false;
+  if (record.ref !== undefined && typeof record.ref !== "string") return false;
+  return true;
+}
+
+/** Enumerate installed external repos by reading each `.source.json`
+ *  under `data/skills/catalog/external/`. Repos whose metadata fails
+ *  shape validation are skipped with a `log.warn`. */
+export async function listInstalledRepos(deps: ExternalInstallOptions = {}): Promise<InstalledRepo[]> {
+  const workspaceRoot = deps.workspaceRoot ?? workspacePath;
+  const root = catalogExternalRoot(workspaceRoot);
+  let entries: string[];
+  try {
+    entries = await readdir(root);
+  } catch {
+    return [];
+  }
+  const out: InstalledRepo[] = [];
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    // `entry` is `readdir`-sourced (tainted). Launder through the
+    // `path.basename` round-trip before any join.
+    const repoId = safeRepoId(entry);
+    if (repoId === null) continue;
+    const repoDir = path.join(root, repoId);
+    if (!(await isDirectory(repoDir))) continue;
+    const metadataPath = path.join(repoDir, SOURCE_METADATA_FILE);
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(await readFile(metadataPath, "utf-8"));
+    } catch {
+      log.warn("skills-external", "metadata missing or unreadable; skipping repo", { repoId });
+      continue;
+    }
+    if (!isRepoMetadata(parsed)) {
+      log.warn("skills-external", "metadata failed shape check; skipping repo", { repoId });
+      continue;
+    }
+    out.push({
+      repoId,
+      url: parsed.url,
+      subpath: parsed.subpath,
+      ref: parsed.ref,
+      sha: parsed.sha,
+      installedAt: parsed.installedAt,
+    });
+  }
+  out.sort((left, right) => left.repoId.localeCompare(right.repoId));
+  return out;
+}

package/server/workspace/skills/external/presets.ts

@@ -0,0 +1,50 @@
+// Bundled external-skill suggestions surfaced by
+// `GET /api/skills/external/suggestions` (#1383 / #1335 PR-C).
+//
+// These are hand-curated repos we recommend to new users. The list
+// ships in the launcher binary — there's no workspace-side state to
+// migrate when entries change across releases. Users discover them
+// through the "+ Add skill repository" modal (UI lands in PR-C2).
+//
+// Adding an entry here is a deliberate editorial act: each new repo
+// expands what new users see by default. Stay conservative — verify
+// the repo's license is permissive, the skill quality is high, and
+// the repo is actively maintained.
+
+export interface ExternalPresetSuggestion {
+  url: string;
+  /** Optional subpath if the repo bundles multiple skills under a
+   *  common dir (Anthropic's `skills/<name>/` layout). Omitted for
+   *  single-skill repos that ship `SKILL.md` at the root. */
+  subpath?: string;
+  /** User-facing repo name. Free-form; UI may show it as the
+   *  collapsible section heading. */
+  displayName: string;
+  description: string;
+  /** SPDX-ish license identifier from the repo's LICENSE file.
+   *  Display-only; not enforced. */
+  license?: string;
+}
+
+export const EXTERNAL_PRESETS: readonly ExternalPresetSuggestion[] = [
+  {
+    url: "https://github.com/anthropics/skills",
+    subpath: "skills",
+    displayName: "Anthropic skills",
+    description: "Anthropic's official skill collection — PDF / Excel / DOCX builders, MCP server scaffolder, and more.",
+    license: "MIT",
+  },
+  {
+    // Engineering-workflow skills that also pay off inside
+    // MulmoClaude's task agent: brainstorming, writing/executing
+    // plans, systematic-debugging, code review. Layout is one-level
+    // (`skills/<name>/SKILL.md`), so the existing one-level
+    // discovery handles it without a scanner change. Verified
+    // 2026-05: MIT, actively maintained, high-quality skills.
+    url: "https://github.com/obra/superpowers",
+    subpath: "skills",
+    displayName: "Superpowers",
+    description: "Battle-tested workflow skills — brainstorming, planning, systematic debugging, TDD, and code review.",
+    license: "MIT",
+  },
+] as const;

package/server/workspace/skills-preset.ts

@@ -1,15 +1,21 @@
-// Preset skills bundled with mulmoclaude (#1210). Sibling to
-// `helps/`: this file owns the boot-time copy from
-// `server/workspace/skills-preset/<slug>/SKILL.md` (shipped with the
-// launcher tarball) into `<workspaceRoot>/.claude/skills/<slug>/SKILL.md`,
-// where Claude Code's slash-command resolver picks them up.
+// Preset skills bundled with mulmoclaude.
 //
-// The launcher overwrites preset entries unconditionally on every
-// boot — preset skills are "factory defaults", not user state. The
-// `mc-` slug prefix is the namespace boundary: anything under
-// `mc-*` belongs to the launcher and may be added / overwritten /
-// removed across releases. Anything WITHOUT the `mc-` prefix is
-// user-owned and never touched.
+// History: introduced in #1210 to ship launcher-managed "factory"
+// skills like `mc-library`. Originally synced straight into
+// `<workspaceRoot>/.claude/skills/<slug>/`, which made every preset
+// auto-active and inflated the Claude system prompt as new presets
+// landed.
+//
+// #1335 PR-A flipped the destination to the catalog
+// (`<workspaceRoot>/data/skills/catalog/preset/<slug>/`). Catalog
+// entries are visible to UI / tooling but NOT discovered by Claude
+// Code's slash-command resolver — they don't enter the system
+// prompt unless the user (or a later UI in PR-B) explicitly copies
+// one into `.claude/skills/`.
+//
+// The launcher overwrites catalog entries unconditionally on every
+// boot — they're factory defaults, not user state. Anything in
+// `.claude/skills/` (active layer) is left untouched.
 //
 // `syncPresetSkills(...)` is exported as a pure-ish helper (takes
 // paths + a logger sink, returns a summary) so tests can drive it
@@ -25,7 +31,10 @@ const SKILL_FILENAME = "SKILL.md";
 export interface SyncPresetSkillsOptions {
   /** Source directory: `<launcher>/server/workspace/skills-preset/`. */
   sourceDir: string;
-  /** Destination directory: `<workspaceRoot>/.claude/skills/`. */
+  /** Destination directory:
+   *  `<workspaceRoot>/data/skills/catalog/preset/`. The catalog
+   *  half of the catalog-vs-active split — entries here are visible
+   *  to UI but NOT to Claude Code's prompt-time skill resolver. */
   destDir: string;
   /** Logger callbacks — kept injectable so tests don't need to
    *  spin up the structured logger. The boot-side wrapper threads
@@ -142,11 +151,14 @@ function removeRetiredPresets(destDir: string, synced: ReadonlySet<string>, opts
   }
 }
 
-/** Copy every preset slug from `sourceDir` into `destDir`, then
- *  remove any `mc-*` entries in `destDir` that no longer have a
- *  source. Slugs without the `mc-` prefix are skipped (with a warn)
- *  on the source side and left untouched on the dest side — that's
- *  how user-authored skills coexist with launcher-managed presets. */
+/** Copy every preset slug from `sourceDir` into `destDir` (the
+ *  preset slot under the catalog root), then remove any `mc-*`
+ *  entries in `destDir` that no longer have a source. The catalog
+ *  preset subdir is fully launcher-owned, so the `mc-*` prefix
+ *  check at destination is defence-in-depth: a stray non-preset
+ *  slug landing in `catalog/preset/` is unexpected, and we'd
+ *  rather skip it than silently delete a directory we don't
+ *  recognise. */
 export function syncPresetSkills(opts: SyncPresetSkillsOptions): SyncPresetSkillsResult {
   const result: SyncPresetSkillsResult = { copied: [], removed: [], skipped: [] };
   if (!existsSync(opts.sourceDir)) {

package/server/workspace/workspace.ts

@@ -41,13 +41,18 @@ export function initWorkspace(): string {
     copyFileSync(path.join(TEMPLATES_DIR, file), path.join(WORKSPACE_PATHS.helps, file));
   }
 
-  // Sync preset skills (#1210) from server/workspace/skills-preset/
-  // into <workspaceRoot>/.claude/skills/. Only `mc-*` slugs are
-  // touched — user-authored skills coexist untouched. Retired
-  // presets (no longer in source) are removed from the workspace.
+  // Sync preset skills from `server/workspace/skills-preset/` into
+  // the catalog (#1335 PR-A). Catalog entries are visible to UI /
+  // tooling but NOT in `.claude/skills/`, so they don't enter
+  // Claude Code's system prompt by default. Activation (catalog →
+  // `.claude/skills/`) lands with the UI in #1335 PR-B; until then
+  // the catalog is reachable by file path only. The dest directory
+  // is created here because it's outside `EAGER_WORKSPACE_DIRS`
+  // (it lives several levels deep and is preset-specific).
+  mkdirSync(WORKSPACE_PATHS.skillsCatalogPreset, { recursive: true });
   syncPresetSkills({
     sourceDir: SKILLS_PRESET_SOURCE_DIR,
-    destDir: WORKSPACE_PATHS.claudeSkills,
+    destDir: WORKSPACE_PATHS.skillsCatalogPreset,
     onInfo: (message, data) => log.info("skills-preset", message, data),
     onWarn: (message, data) => log.warn("skills-preset", message, data),
   });

package/src/App.vue

@@ -158,8 +158,20 @@
             <div v-else-if="selectedResult" class="h-full overflow-auto p-6">
               <pre class="text-sm text-gray-700 whitespace-pre-wrap">{{ JSON.stringify(selectedResult, null, 2) }}</pre>
             </div>
-            <div v-else class="flex items-center justify-center h-full text-gray-600">
-              <p>{{ t("app.startConversation") }}</p>
+            <div v-else class="flex flex-col items-center justify-center h-full px-6 text-center">
+              <span class="material-icons text-5xl text-gray-400 mb-2" aria-hidden="true">{{ sessionRoleIcon }}</span>
+              <p class="text-lg font-medium text-gray-700 mb-4">{{ sessionRoleName }}</p>
+              <div v-if="sessionRoleQueries.length > 0" class="flex flex-wrap gap-2 justify-center max-w-xl">
+                <button
+                  v-for="(query, queryIdx) in sessionRoleQueries"
+                  :key="`${queryIdx}-${query}`"
+                  class="text-sm bg-gray-100 hover:bg-gray-200 text-gray-700 rounded-full px-4 py-2 border border-gray-300 transition-colors"
+                  @click="sendMessage(query)"
+                >
+                  {{ query }}
+                </button>
+              </div>
+              <p v-else class="text-sm text-gray-500">{{ t("app.startConversation") }}</p>
             </div>
           </template>
           <StackView
@@ -223,6 +235,19 @@
             Debug plugin is not loaded. Make sure @mulmoclaude/debug-plugin is built and registered as a preset.
           </div>
           <!-- eslint-enable @intlify/vue-i18n/no-raw-text -->
+          <!-- Encore page. The View branches on `?pendingId`:
+               - With pendingId: chat-on-mount redirect (transient,
+                 ~300ms) for notification clicks — the tick publishes
+                 `/encore?pendingId=<uuid>` URLs and the View
+                 dispatches resolveNotification then full-navigates
+                 to /chat/<chatId>.
+               - Without pendingId: read-only dashboard of active
+                 obligations and their cycle history, reachable from
+                 the top-bar launcher. -->
+          <component :is="encoreViewComponent" v-else-if="currentPage === 'encore' && encoreViewComponent" />
+          <!-- eslint-disable @intlify/vue-i18n/no-raw-text -- encore chat-on-mount page is a transient redirect, not a user-facing surface. -->
+          <div v-else-if="currentPage === 'encore'" class="h-full flex items-center justify-center text-sm text-gray-500">Encore is not loaded.</div>
+          <!-- eslint-enable @intlify/vue-i18n/no-raw-text -->
         </div>
 
         <!-- Bottom bar (Stack chat only — plugin views have no
@@ -328,7 +353,6 @@ import { useGlobalImageErrorRepair } from "./composables/useImageErrorRepair";
 import { useMergedSessions } from "./composables/useMergedSessions";
 import { useLayoutMode } from "./composables/useLayoutMode";
 import { useSidePanelVisible } from "./composables/useSidePanelVisible";
-import { useSelectedResult } from "./composables/useSelectedResult";
 import { useMcpTools } from "./composables/useMcpTools";
 import { useRoles } from "./composables/useRoles";
 import { useCurrentRole } from "./composables/useCurrentRole";
@@ -443,10 +467,11 @@ const { geminiAvailable, sandboxEnabled, cpuLoadRatio, fetchHealth } = useHealth
 const { activeSession, toolResults, sidebarResults, isRunning, activeSessionRunning, statusMessage, toolCallHistory, activeSessionCount, unreadCount } =
   useSessionDerived({ sessionMap, currentSessionId, sessions });
 
-const { selectedResultUuid } = useSelectedResult({
-  activeSession,
-  sessionMap,
-  currentSessionId,
+const selectedResultUuid = computed<string | null>({
+  get: () => activeSession.value?.selectedResultUuid ?? null,
+  set: (val) => {
+    if (activeSession.value) activeSession.value.selectedResultUuid = val;
+  },
 });
 
 // Display name and icon of the role the active session was created
@@ -661,6 +686,11 @@ const selectedResult = computed(() => toolResults.value.find((result) => result.
 // the /debug branch in the template lights up without a refresh.
 const debugViewComponent = computed(() => getPlugin("manageDebug")?.viewComponent ?? null);
 
+// Encore plugin View — built-in plugin under src/plugins/encore/.
+// Mounted at /encore — the chat-on-mount page after a notification-bell click
+// (View.vue dispatches resolveNotification on mount and redirects).
+const encoreViewComponent = computed(() => getPlugin(TOOL_NAMES.manageEncore)?.viewComponent ?? null);
+
 // Google Maps API key from `AppSettings.googleMapsApiKey`. Fetched
 // once on mount and refreshed whenever Settings reports a save.
 //
@@ -855,7 +885,6 @@ async function loadSession(sessionId: string) {
     id: sessionId,
     entries: response.data,
     defaultRoleId: roles.value[0]?.id ?? "",
-    urlResult: typeof route.query.result === "string" ? route.query.result : null,
     serverSummary: sessions.value.find((summary) => summary.id === sessionId),
     nowIso: new Date().toISOString(),
   });